ChebyshevII.h

 
#pragma once
 
#include "Common.h"
#include "Cascade.h"
#include "PoleFilter.h"
#include "State.h"
 
namespace Iir {

namespace ChebyshevII {

class IIR_EXPORT AnalogLowPass : public LayoutBase
{
public:
        AnalogLowPass ();
 
        void design (const int numPoles,
                     double stopBandDb);
 
private:
        int m_numPoles = 0;
        double m_stopBandDb = 0.0;
};
 

class IIR_EXPORT AnalogLowShelf : public LayoutBase
{
public:
        AnalogLowShelf ();
 
        void design (int numPoles,
                     double gainDb,
                     double stopBandDb);
 
private:
        int m_numPoles = 0;
        double m_stopBandDb = 0.0;
        double m_gainDb = 0.0;
};
 
//------------------------------------------------------------------------------
 
struct IIR_EXPORT LowPassBase : PoleFilterBase <AnalogLowPass>
{
        void setup (int order,
                    double cutoffFrequency,
                    double stopBandDb);
};
 
struct IIR_EXPORT HighPassBase : PoleFilterBase <AnalogLowPass>
{
        void setup (int order,
                    double cutoffFrequency,
                    double stopBandDb);
};
 
struct IIR_EXPORT BandPassBase : PoleFilterBase <AnalogLowPass>
{
        void setup (int order,
                    double centerFrequency,
                    double widthFrequency,
                    double stopBandDb);
};
 
struct IIR_EXPORT BandStopBase : PoleFilterBase <AnalogLowPass>
{
        void setup (int order,
                    double centerFrequency,
                    double widthFrequency,
                    double stopBandDb);
};
 
struct IIR_EXPORT LowShelfBase : PoleFilterBase <AnalogLowShelf>
{
        void setup (int order,
                    double cutoffFrequency,
                    double gainDb,
                    double stopBandDb);
};
 
struct IIR_EXPORT HighShelfBase : PoleFilterBase <AnalogLowShelf>
{
        void setup (int order,
                    double cutoffFrequency,
                    double gainDb,
                    double stopBandDb);
};
 
struct IIR_EXPORT BandShelfBase : PoleFilterBase <AnalogLowShelf>
{
        void setup (int order,
                    double centerFrequency,
                    double widthFrequency,
                    double gainDb,
                    double stopBandDb);
};
 
//------------------------------------------------------------------------------
 
//
// Userland filters
//

template <int FilterOrder = DEFAULT_FILTER_ORDER, class StateType = DEFAULT_STATE>
struct LowPass : PoleFilter <LowPassBase, StateType, FilterOrder>
{
        void setup (double sampleRate,
                    double cutoffFrequency,
                    double stopBandDb) {
                LowPassBase::setup (FilterOrder,
                                    cutoffFrequency / sampleRate,
                                    stopBandDb);
        }

        void setup (int reqOrder,
                    double sampleRate,
                    double cutoffFrequency,
                    double stopBandDb) {
                if (reqOrder > FilterOrder) throw_invalid_argument(orderTooHigh);
                LowPassBase::setup (reqOrder,
                                    cutoffFrequency / sampleRate,
                                    stopBandDb);
        }
 
 
 
 

        void setupN(double cutoffFrequency,
                    double stopBandDb) {
                LowPassBase::setup (FilterOrder,
                                    cutoffFrequency,
                                    stopBandDb);
        }

        void setupN(int reqOrder,
                    double cutoffFrequency,
                    double stopBandDb) {
                if (reqOrder > FilterOrder) throw_invalid_argument(orderTooHigh);
                LowPassBase::setup (reqOrder,
                                    cutoffFrequency,
                                    stopBandDb);
        }
 
};

template <int FilterOrder = DEFAULT_FILTER_ORDER, class StateType = DEFAULT_STATE>
struct HighPass : PoleFilter <HighPassBase, StateType, FilterOrder>
{
        void setup (double sampleRate,
                    double cutoffFrequency,
                    double stopBandDb) {
                HighPassBase::setup (FilterOrder,
                                     cutoffFrequency / sampleRate,
                                     stopBandDb);
        }

        void setup (int reqOrder,
                    double sampleRate,
                    double cutoffFrequency,
                    double stopBandDb) {
                if (reqOrder > FilterOrder) throw_invalid_argument(orderTooHigh);
                HighPassBase::setup (reqOrder,
                                     cutoffFrequency / sampleRate,
                                     stopBandDb);
        }
 
 
 

        void setupN(double cutoffFrequency,
                    double stopBandDb) {
                HighPassBase::setup (FilterOrder,
                                     cutoffFrequency,
                                     stopBandDb);
        }

        void setupN(int reqOrder,
                    double cutoffFrequency,
                    double stopBandDb) {
                if (reqOrder > FilterOrder) throw_invalid_argument(orderTooHigh);
                HighPassBase::setup (reqOrder,
                                     cutoffFrequency,
                                     stopBandDb);
        }
 
};

template <int FilterOrder = DEFAULT_FILTER_ORDER, class StateType = DEFAULT_STATE>
struct BandPass : PoleFilter <BandPassBase, StateType, FilterOrder, FilterOrder*2>
{
        void setup (double sampleRate,
                    double centerFrequency,
                    double widthFrequency,
                    double stopBandDb) {
                BandPassBase::setup (FilterOrder,
                                     centerFrequency / sampleRate,
                                     widthFrequency / sampleRate,
                                     stopBandDb);
        }

        void setup (int reqOrder,
                    double sampleRate,
                    double centerFrequency,
                    double widthFrequency,
                    double stopBandDb) {
                if (reqOrder > FilterOrder) throw_invalid_argument(orderTooHigh);
                BandPassBase::setup (reqOrder,
                                     centerFrequency / sampleRate,
                                     widthFrequency / sampleRate,
                                     stopBandDb);
        }
 
 
 

        void setupN(double centerFrequency,
                    double widthFrequency,
                    double stopBandDb) {
                BandPassBase::setup (FilterOrder,
                                     centerFrequency,
                                     widthFrequency,
                                     stopBandDb);
        }

        void setupN(int reqOrder,
                    double centerFrequency,
                    double widthFrequency,
                    double stopBandDb) {
                if (reqOrder > FilterOrder) throw_invalid_argument(orderTooHigh);
                BandPassBase::setup (reqOrder,
                                     centerFrequency,
                                     widthFrequency,
                                     stopBandDb);
        }
};

template <int FilterOrder = DEFAULT_FILTER_ORDER, class StateType = DEFAULT_STATE>
struct BandStop : PoleFilter <BandStopBase, StateType, FilterOrder, FilterOrder*2>
{
        void setup (double sampleRate,
                    double centerFrequency,
                    double widthFrequency,
                    double stopBandDb) {
                BandStopBase::setup (FilterOrder,
                                     centerFrequency / sampleRate,
                                     widthFrequency / sampleRate,
                                     stopBandDb);
        }

        void setup (int reqOrder,
                    double sampleRate,
                    double centerFrequency,
                    double widthFrequency,
                    double stopBandDb) {
                if (reqOrder > FilterOrder) throw_invalid_argument(orderTooHigh);
                BandStopBase::setup (reqOrder,
                                     centerFrequency / sampleRate,
                                     widthFrequency / sampleRate,
                                     stopBandDb);
        }
 
 
 

        void setupN(double centerFrequency,
                    double widthFrequency,
                    double stopBandDb) {
                BandStopBase::setup (FilterOrder,
                                     centerFrequency,
                                     widthFrequency,
                                     stopBandDb);
        }

        void setupN(int reqOrder,
                    double centerFrequency,
                    double widthFrequency,
                    double stopBandDb) {
                if (reqOrder > FilterOrder) throw_invalid_argument(orderTooHigh);
                BandStopBase::setup (reqOrder,
                                     centerFrequency,
                                     widthFrequency,
                                     stopBandDb);
        }
};

template <int FilterOrder = DEFAULT_FILTER_ORDER, class StateType = DEFAULT_STATE>
struct LowShelf : PoleFilter <LowShelfBase, StateType, FilterOrder>
{
        void setup (double sampleRate,
                    double cutoffFrequency,
                    double gainDb,
                    double stopBandDb) {
                LowShelfBase::setup (FilterOrder,
                                     cutoffFrequency / sampleRate,
                                     gainDb,
                                     stopBandDb);
        }
        
        void setup (int reqOrder,
                    double sampleRate,
                    double cutoffFrequency,
                    double gainDb,
                    double stopBandDb) {
                if (reqOrder > FilterOrder) throw_invalid_argument(orderTooHigh);
                LowShelfBase::setup (reqOrder,
                                     cutoffFrequency / sampleRate,
                                     gainDb,
                                     stopBandDb);
        }
        
 
 
 

        void setupN(double cutoffFrequency,
                    double gainDb,
                    double stopBandDb) {
                LowShelfBase::setup (FilterOrder,
                                     cutoffFrequency,
                                     gainDb,
                                     stopBandDb);
        }
        
        void setupN(int reqOrder,
                    double cutoffFrequency,
                    double gainDb,
                    double stopBandDb) {
                if (reqOrder > FilterOrder) throw_invalid_argument(orderTooHigh);
                LowShelfBase::setup (reqOrder,
                                     cutoffFrequency,
                                     gainDb,
                                     stopBandDb);
        }
        
};

template <int FilterOrder = DEFAULT_FILTER_ORDER, class StateType = DEFAULT_STATE>
struct HighShelf : PoleFilter <HighShelfBase, StateType, FilterOrder>
{
        void setup (double sampleRate,
                    double cutoffFrequency,
                    double gainDb,
                    double stopBandDb) {
                HighShelfBase::setup (FilterOrder,
                                      cutoffFrequency / sampleRate,
                                      gainDb,
                                      stopBandDb);
        }
        
        void setup (int reqOrder,
                    double sampleRate,
                    double cutoffFrequency,
                    double gainDb,
                    double stopBandDb) {
                if (reqOrder > FilterOrder) throw_invalid_argument(orderTooHigh);
                HighShelfBase::setup (reqOrder,
                                      cutoffFrequency / sampleRate,
                                      gainDb,
                                      stopBandDb);
        }
        
 
 
 
 

        void setupN(double cutoffFrequency,
                    double gainDb,
                    double stopBandDb) {
                HighShelfBase::setup (FilterOrder,
                                      cutoffFrequency,
                                      gainDb,
                                      stopBandDb);
        }
        
        void setupN(int reqOrder,
                    double cutoffFrequency,
                    double gainDb,
                    double stopBandDb) {
                if (reqOrder > FilterOrder) throw_invalid_argument(orderTooHigh);
                HighShelfBase::setup (reqOrder,
                                      cutoffFrequency,
                                      gainDb,
                                      stopBandDb);
        }
        
};

template <int FilterOrder = DEFAULT_FILTER_ORDER, class StateType = DEFAULT_STATE>
struct BandShelf : PoleFilter <BandShelfBase, StateType, FilterOrder, FilterOrder*2>
{
        void setup (double sampleRate,
                    double centerFrequency,
                    double widthFrequency,
                    double gainDb,
                    double stopBandDb) {
                BandShelfBase::setup (FilterOrder,
                                      centerFrequency / sampleRate,
                                      widthFrequency / sampleRate,
                                      gainDb,
                                      stopBandDb);
        }
          

        void setup (int reqOrder,
                    double sampleRate,
                    double centerFrequency,
                    double widthFrequency,
                    double gainDb,
                    double stopBandDb) {
                if (reqOrder > FilterOrder) throw_invalid_argument(orderTooHigh);
                BandShelfBase::setup (reqOrder,
                                      centerFrequency / sampleRate,
                                      widthFrequency / sampleRate,
                                      gainDb,
                                      stopBandDb);
        }
          
 
 
 
 
 

        void setupN(double centerFrequency,
                    double widthFrequency,
                    double gainDb,
                    double stopBandDb) {
                BandShelfBase::setup (FilterOrder,
                                      centerFrequency,
                                      widthFrequency,
                                      gainDb,
                                      stopBandDb);
        }
          

        void setupN(int reqOrder,
                    double centerFrequency,
                    double widthFrequency,
                    double gainDb,
                    double stopBandDb) {
                if (reqOrder > FilterOrder) throw_invalid_argument(orderTooHigh);
                BandShelfBase::setup (reqOrder,
                                      centerFrequency,
                                      widthFrequency,
                                      gainDb,
                                      stopBandDb);
        }
          
 
};
 
}
 
}