Biquad.h

 
#ifndef IIR1_BIQUAD_H
#define IIR1_BIQUAD_H
 
#include "Common.h"
#include "MathSupplement.h"
#include "Types.h"
 
namespace Iir {
        
        struct IIR_EXPORT BiquadPoleState;
        
/*
 * Holds coefficients for a second order Infinite Impulse Response
 * digital filter. This is the building block for all IIR filters.
 *
 */
        class IIR_EXPORT Biquad {
        public:
 
        Biquad() = default;
        
        complex_t response (double normalizedFrequency) const;
 
        std::vector<PoleZeroPair> getPoleZeros () const;
 
        double getA0 () const { return m_a0; }
 
        double getA1 () const { return m_a1*m_a0; }
 
        double getA2 () const { return m_a2*m_a0; }
 
        double getB0 () const { return m_b0*m_a0; }
 
        double getB1 () const { return m_b1*m_a0; }
 
        double getB2 () const { return m_b2*m_a0; }
 
        template <class StateType>
        inline double filter(double s, StateType& state) const
        {
                return state.filter(s, *this);
        }
 
        public:
        void setCoefficients (double a0, double a1, double a2,
                              double b0, double b1, double b2);
 
        void setOnePole (complex_t pole, complex_t zero);
 
        void setTwoPole (complex_t pole1, complex_t zero1,
                         complex_t pole2, complex_t zero2);
 
        void setPoleZeroPair (const PoleZeroPair& pair)
        {
                if (pair.isSinglePole ())
                        setOnePole (pair.poles.first, pair.zeros.first);
                else
                        setTwoPole (pair.poles.first, pair.zeros.first,
                                    pair.poles.second, pair.zeros.second);
        }
 
        void setPoleZeroForm (const BiquadPoleState& bps);
 
        void setIdentity ();
 
        void applyScale (double scale);
 
        public:
        double m_a0 = 1.0;
        double m_a1 = 0.0;
        double m_a2 = 0.0;
        double m_b1 = 0.0;
        double m_b2 = 0.0;
        double m_b0 = 1.0;
        };
 
//------------------------------------------------------------------------------
 
        
        struct IIR_EXPORT BiquadPoleState : PoleZeroPair
        {
                BiquadPoleState () = default;
 
                explicit BiquadPoleState (const Biquad& s);
 
                double gain = 1.0;
        };
 
}
        
#endif