Butterworth.h

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

namespace Butterworth {

class IIR_EXPORT AnalogLowPass : public LayoutBase
{
public:
        AnalogLowPass ();
 
        void design (const int numPoles);
 
private:
        int m_numPoles = 0;
};
 
//------------------------------------------------------------------------------

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

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

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

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

template <int FilterOrder = DEFAULT_FILTER_ORDER, class StateType = DEFAULT_STATE>
struct HighPass : PoleFilter <HighPassBase, StateType, FilterOrder>
{

        void setup (double sampleRate,
                    double cutoffFrequency) {
                HighPassBase::setup (FilterOrder,
                                     cutoffFrequency / sampleRate);
        }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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