Biquad.h

 
#ifndef IIR1_BIQUAD_H
#define IIR1_BIQUAD_H
 
#include "Common.h"
#include "MathSupplement.h"
#include "Types.h"
 
namespace Iir {
 
        struct DllExport BiquadPoleState;
 
/*
 * Holds coefficients for a second order Infinite Impulse Response
 * digital filter. This is the building block for all IIR filters.
 *
 */
        class DllExport Biquad
        {
        public:
                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 DllExport BiquadPoleState : PoleZeroPair
        {
                BiquadPoleState () = default;
 
                explicit BiquadPoleState (const Biquad& s);
 
                double gain = 1.0;
        };
 
}
        
#endif