ChebyshevI.h

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

namespace ChebyshevI {

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

class IIR_EXPORT AnalogLowShelf : public LayoutBase
{
public:
        AnalogLowShelf ();
 
        void design (int numPoles,
                     double gainDb,
                     double rippleDb);
 
private:
        int m_numPoles = 0;
        double m_rippleDb = 0.0;
        double m_gainDb = 0.0;
};
 
//------------------------------------------------------------------------------
 
struct IIR_EXPORT LowPassBase : PoleFilterBase <AnalogLowPass>
{
  void setup (int order,
              double cutoffFrequency,
              double rippleDb);
};
 
struct IIR_EXPORT HighPassBase : PoleFilterBase <AnalogLowPass>
{
  void setup (int order,
              double cutoffFrequency,
              double rippleDb);
};
 
struct IIR_EXPORT BandPassBase : PoleFilterBase <AnalogLowPass>
{
  void setup (int order,
              double centerFrequency,
              double widthFrequency,
              double rippleDb);
};
 
struct IIR_EXPORT BandStopBase : PoleFilterBase <AnalogLowPass>
{
  void setup (int order,
              double centerFrequency,
              double widthFrequency,
              double rippleDb);
};
 
struct IIR_EXPORT LowShelfBase : PoleFilterBase <AnalogLowShelf>
{
  void setup (int order,
              double cutoffFrequency,
              double gainDb,
              double rippleDb);
};
 
struct IIR_EXPORT HighShelfBase : PoleFilterBase <AnalogLowShelf>
{
  void setup (int order,
              double cutoffFrequency,
              double gainDb,
              double rippleDb);
};
 
struct IIR_EXPORT BandShelfBase : PoleFilterBase <AnalogLowShelf>
{
  void setup (int order,
              double centerFrequency,
              double widthFrequency,
              double gainDb,
              double rippleDb);
};
 
//------------------------------------------------------------------------------
 
//
// 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 rippleDb) {
                        LowPassBase::setup (FilterOrder,
                                            cutoffFrequency / sampleRate,
                                            rippleDb);
                }
                
                void setup (int reqOrder,
                            double sampleRate,
                            double cutoffFrequency,
                            double rippleDb) {
                        if (reqOrder > FilterOrder) throw_invalid_argument(orderTooHigh);
                        LowPassBase::setup (reqOrder,
                                            cutoffFrequency / sampleRate,
                                            rippleDb);
                }
 
 

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

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

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

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

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

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 rippleDb) {
                        BandPassBase::setup (FilterOrder,
                               centerFrequency / sampleRate,
                               widthFrequency / sampleRate,
                               rippleDb);
                }

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

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

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

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 rippleDb) {
                        BandStopBase::setup (FilterOrder,
                                             centerFrequency / sampleRate,
                                             widthFrequency / sampleRate,
                                             rippleDb);
                }

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

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

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

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 rippleDb) {
                        LowShelfBase::setup (FilterOrder,
                                             cutoffFrequency / sampleRate,
                                             gainDb,
                                             rippleDb);
                }
        
                void setup (int reqOrder,
                            double sampleRate,
                            double cutoffFrequency,
                            double gainDb,
                            double rippleDb) {
                        if (reqOrder > FilterOrder) throw_invalid_argument(orderTooHigh);
                        LowShelfBase::setup (reqOrder,
                                             cutoffFrequency / sampleRate,
                                             gainDb,
                                             rippleDb);
                }
 
 

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

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 rippleDb) {
                        HighShelfBase::setup (FilterOrder,
                               cutoffFrequency / sampleRate,
                               gainDb,
                               rippleDb);
                }

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

                void setupN(double cutoffFrequency,
                            double gainDb,
                            double rippleDb) {
                        HighShelfBase::setup (FilterOrder,
                               cutoffFrequency,
                               gainDb,
                               rippleDb);
                }

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

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 rippleDb) {
                        BandShelfBase::setup (FilterOrder,
                                              centerFrequency / sampleRate,
                                              widthFrequency / sampleRate,
                                              gainDb,
                                              rippleDb);
                        
                }
                
                void setup (int reqOrder,
                            double sampleRate,
                            double centerFrequency,
                            double widthFrequency,
                            double gainDb,
                            double rippleDb) {
                        if (reqOrder > FilterOrder) throw_invalid_argument(orderTooHigh);
                        BandShelfBase::setup (reqOrder,
                                              centerFrequency / sampleRate,
                                              widthFrequency / sampleRate,
                                              gainDb,
                                              rippleDb);
 
                }
 
 
 
                
                void setupN(double centerFrequency,
                            double widthFrequency,
                            double gainDb,
                            double rippleDb) {
                        BandShelfBase::setup (FilterOrder,
                                              centerFrequency,
                                              widthFrequency,
                                              gainDb,
                                              rippleDb);
                        
                }
                
                void setupN(int reqOrder,
                            double centerFrequency,
                            double widthFrequency,
                            double gainDb,
                            double rippleDb) {
                        if (reqOrder > FilterOrder) throw_invalid_argument(orderTooHigh);
                        BandShelfBase::setup (reqOrder,
                                              centerFrequency,
                                              widthFrequency,
                                              gainDb,
                                              rippleDb);
 
                }
 
        };
 
}
 
}