iirfilter.h

Go to the documentation of this file.

/*
 MCL
 Copyright (c) 2012-18, Enzo De Sena
 All rights reserved.
 
 Authors: Enzo De Sena, enzodesena@gmail.com
 */

#ifndef MCL_IIRFILTER_H
#define MCL_IIRFILTER_H

#include "digitalfilter.h"
#include "vectorop.h"
#include "constants.h"

namespace mcl {

  
class IirFilter : public DigitalFilter {
public:
  IirFilter();
  
  IirFilter(std::vector<Real> B,std::vector<Real> A);
  
  
  virtual Real Filter(const Real input) noexcept;
  
  virtual void Filter(const Real* input_data, const Int num_samples,
                      Real* output_data) noexcept;
  
  using DigitalFilter::Filter;
  
  Int order() const noexcept;
  
  void SetCoefficients(const std::vector<Real>& B,
                       const std::vector<Real>& A) noexcept;
  
  void SetCoefficients(const IirFilter& filter) noexcept;
  
  Real GetNumeratorCoefficient(const Int coeff_id) const noexcept;
  
  Real GetDenominatorCoefficient(const Int coeff_id) const noexcept;
  
  void SetNumeratorCoefficient(const Int coeff_id,
                               const Real value) noexcept;
  
  inline void SetDenominatorCoefficient(const Int coeff_id,
                                        const Real value) noexcept;
  
  std::vector<Real> B() const;
  
  std::vector<Real> A() const;
  
  void Reset();
  
  static bool Test();
  
  IirFilter & operator= (const IirFilter &);
  
  IirFilter (const IirFilter&);
  
  virtual ~IirFilter();
  
private:
  std::vector<Real> B_;
  std::vector<Real> A_;
  
  // By storing A[0] before normalisation we can output B() and A() before
  // normalisation while keeping the internal representation normalised
  Real A0_;
  
  Real* state_;
};
  
class IirFilterBank : public FilterBank {
private:
  std::vector<IirFilter> filters_;
  
public:
  IirFilterBank(const std::vector<IirFilter>& filters) noexcept :
        filters_(filters) {}
  
  virtual Int num_filters() noexcept { return filters_.size(); }
  
  virtual std::vector<Real> Filter(const Real input);
  
  virtual std::vector<std::vector<Real> >
  Filter(const std::vector<Real>& input);
  
  virtual void Reset();
};
  
//
//  /** Implements a first-order IIR low-pass filter with a given decay constant. */
//  class RampSmoothingFilter : public DigitalFilter {
//  public:
//    
//    /**
//     @param[in] ramp_samples number of samples after which the value is
//     to 1/e away from target value. */
//    RampSmoothingFilter(const Real ramp_samples) noexcept {
//      ASSERT_WITH_MESSAGE(std::isgreaterequal(ramp_samples, 0),
//                          "Decay constant cannot be negative ");
//      
//      
//    }
//    
//    virtual Real Filter(const Real input) noexcept {
//      return filter_.Filter(input);
//    }
//    
//    using DigitalFilter::Filter;
//    
//    virtual void Reset() noexcept { filter_.Reset(); }
//    
//    
//  private:
//  };
//  
//class LowPassSmoothingFilter : public DigitalFilter {
//public:
//  
//  /**
//   @param[in] ramp_samples number of samples after which the value is
//   to 1/e away from target value. */
//  LowPassSmoothingFilter(const Real ramp_samples) noexcept {
//    ASSERT_WITH_MESSAGE(std::isgreaterequal(ramp_samples, 0),
//                        "Decay constant cannot be negative ");
//    
//    Real a1 = exp(-1.0/ramp_samples);
//    Real b0 = 1.0 - a1;
//    filter_ = IirFilter(mcl::BinaryVector(b0, 0.0),
//                        mcl::BinaryVector(1.0, -a1));
//  }
//  
//  virtual Real Filter(const Real input) noexcept {
//    return filter_.Filter(input);
//  }
//  
//  using DigitalFilter::Filter;
//  
//  virtual void Reset() noexcept { filter_.Reset(); }
//  
//  
//private:
//  IirFilter filter_;
//};
  
IirFilter IdenticalFilter();

IirFilter GainFilter(const Real gain);

IirFilter WallFilter(WallType wall_type, Real sampling_frequency);

IirFilter PinkifierFilter();
  
} // namespace mcl

#endif