PoleFilter.h

 
#pragma once
 
#include "Common.h"
#include "MathSupplement.h"
#include "Cascade.h"
 
namespace Iir {
 
/***
 * Base for filters designed via algorithmic placement of poles and zeros.
 *
 * Typically, the filter is first designed as a half-band low pass or
 * low shelf analog filter (s-plane). Then, using a transformation such
 * as the ones from Constantinides, the poles and zeros of the analog filter
 * are calculated in the z-plane.
 *
 ***/

        class IIR_EXPORT PoleFilterBase2 : public Cascade
        {
        public:
                // This gets the poles/zeros directly from the digital
                // prototype. It is used to double check the correctness
                // of the recovery of pole/zeros from biquad coefficients.
                //
                // It can also be used to accelerate the interpolation
                // of pole/zeros for parameter modulation, since a pole
                // filter already has them calculated
 
                PoleFilterBase2() = default;
 
                std::vector<PoleZeroPair> getPoleZeros () const
                {
                        std::vector<PoleZeroPair> vpz;
                        const int pairs = (m_digitalProto.getNumPoles () + 1) / 2;
                        for (int i = 0; i < pairs; ++i)
                                vpz.push_back (m_digitalProto[i]);
                        return vpz;
                }
        
        protected:
                LayoutBase m_digitalProto = {};
        };
 

        template <class AnalogPrototype>
        class PoleFilterBase : public PoleFilterBase2
        {
        protected:
                void setPrototypeStorage (const LayoutBase& analogStorage,
                                          const LayoutBase& digitalStorage)
                {
                        m_analogProto.setStorage (analogStorage);
                        m_digitalProto = digitalStorage;
                }
                
        protected:
                AnalogPrototype m_analogProto = {};
        };
 
//------------------------------------------------------------------------------

        template <class BaseClass,
                  class StateType,
                  int MaxAnalogPoles,
                  int MaxDigitalPoles = MaxAnalogPoles>
        struct PoleFilter : BaseClass
                , CascadeStages <(MaxDigitalPoles + 1) / 2 , StateType>
        {
        public:
                PoleFilter ()
                        {
                                // This glues together the factored base classes
                                // with the templatized storage classes.
                                BaseClass::setCascadeStorage (this->getCascadeStorage());
                                BaseClass::setPrototypeStorage (m_analogStorage, m_digitalStorage);
                                CascadeStages<(MaxDigitalPoles + 1) / 2 , StateType>::reset();
                        }
                
                PoleFilter(const PoleFilter&) = default;
                
                PoleFilter& operator=(const PoleFilter&)
                        {
                                // Reset the filter state when copied for now
                                CascadeStages<(MaxDigitalPoles + 1) / 2 , StateType>::reset();
                                return *this;
                        }
                
        private:
                Layout <MaxAnalogPoles> m_analogStorage = {};
                Layout <MaxDigitalPoles> m_digitalStorage = {};
        };
 
//------------------------------------------------------------------------------


        class IIR_EXPORT LowPassTransform
        {
        public:
        LowPassTransform (double fc,
                          LayoutBase& digital,
                          LayoutBase const& analog);
 
        private:
        complex_t transform (complex_t c);
 
        double f = 0.0;
        };
 
//------------------------------------------------------------------------------

        class IIR_EXPORT HighPassTransform
        {
        public:
        HighPassTransform (double fc,
                           LayoutBase& digital,
                           LayoutBase const& analog);
 
        private:
        complex_t transform (complex_t c);
 
        double f = 0.0;
        };
 
//------------------------------------------------------------------------------

        class IIR_EXPORT BandPassTransform
        {
 
        public:
        BandPassTransform (double fc,
                           double fw,
                           LayoutBase& digital,
                           LayoutBase const& analog);
 
        private:
        ComplexPair transform (complex_t c);
 
        double wc = 0.0;
        double wc2 = 0.0;
        double a = 0.0;
        double b = 0.0;
        double a2 = 0.0;
        double b2 = 0.0;
        double ab = 0.0;
        double ab_2 = 0.0;
        };
 
//------------------------------------------------------------------------------

        class IIR_EXPORT BandStopTransform
        {
        public:
        BandStopTransform (double fc,
                           double fw,
                           LayoutBase& digital,
                           LayoutBase const& analog);
 
        private:
        ComplexPair transform (complex_t c);
 
        double wc = 0.0;
        double wc2 = 0.0;
        double a = 0.0;
        double b = 0.0;
        double a2 = 0.0;
        double b2 = 0.0;
        };
 
}