OptimalFir::RemezImpulse Function

Overload List

#	Signature	Description
1	bool RemezImpulse(TVec H, const* DewArray<double> &W, double Ripple, TFilterType FilterType, double Gain = 1, double FS = 2, bool EnsureOdd = true);	Design an optimal equiripple FIR filter with Parks-McClellan algorithm.
2	bool RemezImpulse(TVec H, const* DewArray<double> &W, TFilterType FilterType, double Gain = 1, double FS = 2);	Design an optimal equiripple FIR filter with Parks-McClellan algorithm.

Overload 1: bool RemezImpulse(TVec *H, const DewArray<double> &W, double Ripple, TFilterType FilterType, double Gain = 1, double FS = 2, bool EnsureOdd = true);

Design an optimal equiripple FIR filter with Parks-McClellan algorithm.

#	Name	Type	Description
1	H	TVec *	H vector holds the impulse response on exit.
2	W	const DewArray<double> &	Array which can hold only 2 (highpass/lowpass definition) or 4(bandpass/bandstop definition) parameters.
3	Ripple	double	The required linear ripple of the passband and 20*Log10(Ripple) is the required attenuation of the stop band.
4	FilterType	TFilterType	Parameter defines the filter type.
5	Gain = 1	double	Specifies the gain of the passband.
6	FS = 2	double	The sampling frequency used to normalize transition band edges defined in the W array. Default value for FS is 2.
7	EnsureOdd = true	bool	Resulting filter length will be odd (not divisable by 2), if set to true. Default is true.

Remarks:

The resulting impulse response is placed in H. Length of the filter is automatically estimated from the required Ripple and transition bandwidth. Function returns True, if the filter was succesfully designed. This does not guarantee that filter specifications have been meet.

This routine is a simplified version of Remez and can be used to design: Lowpass, bandpass, bandstop, highpass, differentiators and hilbert transformers.

Note:

RemezImpulse routine designes FIR filters about 10-20% shorter than the KaiserImpulse routine.

Examples

#include "MtxExpr.h"
#include "Units.OptimalFIR.h"
#include "Units.SignalUtils.h"

using namespace Dew;
using namespace Dew::Math;
using namespace Dew::Signal;
using namespace Dew::Signal::Units::OptimalFir;
using namespace Dew::Signal::Units::SignalUtils;

void Example()
{
    Vector H, Response;
    double TransBW, Ripple;

    //Assumed sampling frequency = 2
    TransBW = 0.02; //transition bandwidth in Hz.
    Ripple = 0.001;
    //Lowpass filter
    RemezImpulse(H, DewArray<double>{0.3, 0.3+TransBW}, Ripple, TFilterType::ftLowpass);
    //Highpass filter
    //           RemezImpulse(H, DewArray<double>{0.3, 0.3+TransBW}, Ripple, TFilterType::ftHighpass);
    //Bandpass filter
    //           RemezImpulse(H, DewArray<double>{0.3, 0.3+TransBW, 0.5-TransBW, 0.5}, Ripple, TFilterType::ftBandpass);
    //Bandstop filter
    //           RemezImpulse(H, DewArray<double>{0.3, 0.3+TransBW, 0.5-TransBW, 0.5}, Ripple, TFilterType::ftBandstop);


    //  Type III Hilbert transformer
    //           RemezImpulse(H, DewArray<double>{TransBW, 1-TransBW}, Ripple, TFilterType::ftHilbertIII);

    //  Type IV Hilbert transformer
    //           RemezImpulse(H, DewArray<double>{TransBW, 1}, Ripple, TFilterType::ftHilbertIV);

    //  Type III linear phase differentiator filter
    //           KaiserImpulse(H, DewArray<double>{1-TransBW, 1}, Ripple, TFilterType::ftDifferentiatorIII);
    //           H.Scale(2);  //Scale by sampling frequency

    //  Type IV linear phase differentiator filter
    //           KaiserImpulse(H, DewArray<double>{1-TransBW, 1}, Ripple, TFilterType::ftDifferentiatorIV);
    //           H.Scale(2);  //Scale by sampling frequency

    //  Type III differentiator filter
    //           RemezImpulse(H, DewArray<double>{0, 1-TransBW}, Ripple, TFilterType::ftDifferentiatorIII);
    //           H.Scale(2);  //Scale by sampling frequency

    //  Type IV differentiator filter
    //           RemezImpulse(H, DewArray<double>{0, 1-TransBW}, Ripple, TFilterType::ftDifferentiatorIV);
    //           H.Scale(2);  //Scale by sampling frequency

    // Type III 2x differentiator filter (remez)
    //           RemezImpulse(H, DewArray<double>{0, 1-TransBW}, Ripple, TFilterType::ftDoubleDifferentiatorIII);
    //           H.Scale(Sqr(2));  //Scale by sampling frequency

    // Type IV 2x differentiator filter (remez)
    //           RemezImpulse(H, DewArray<double>{0, 1-TransBW}, Ripple, TFilterType::ftDoubleDifferentiatorIV);
    //           H.Scale(Sqr(2));  //Scale by sampling frequency

    // Type III integrator  filter (remez).';
    //           RemezImpulse(H, DewArray<double>{TransBW, 1-TransBW}, Ripple, TFilterType::ftIntegratorIII);
    //           H.Scale(1.0/2);  //Scale by sampling frequency

    // Type IV integrator  filter (remez).';
    //           RemezImpulse(H, DewArray<double>{TransBW, 1}, Ripple, TFilterType::ftIntegratorIV);
    //           H.Scale(1.0/2);  //Scale by sampling frequency

    //  Type III 2x integrator  filter (remez).';
    //           RemezImpulse(H, DewArray<double>{TransBW, 1-TransBW}, Ripple, TFilterType::ftDoubleIntegratorIII);
    //           H.Scale(Sqr(1.0/2));  //Scale by sampling frequency

    //  Type IV 2x integrator  filter (remez).';
    //           RemezImpulse(H, DewArray<double>{TransBW, 1}, Ripple, TFilterType::ftDoubleIntegratorIV);
    //           H.Scale(Sqr(1.0/2));  //Scale by sampling frequency

    FrequencyResponse(H, nullptr, Response);
}

See Also: OptimalFir::remez

Declared in Dew::Signal::Units::OptimalFir · Dew.Signal/Units.OptimalFIR.h · Cross-compiler

Overload 2: bool RemezImpulse(TVec *H, const DewArray<double> &W, TFilterType FilterType, double Gain = 1, double FS = 2);

Design an optimal equiripple FIR filter with Parks-McClellan algorithm.

#	Name	Type
1	H	TVec *
2	W	const DewArray<double> &
3	FilterType	TFilterType
4	Gain = 1	double
5	FS = 2	double

Remarks:

Required length of the filter must be preset by setting H.Length. H vector holds the impulse response on exit.

Examples

#include "MtxExpr.h"
#include "Units.Math387.h"
#include "Units.OptimalFIR.h"
#include "Units.SignalUtils.h"

using namespace Dew;
using namespace Dew::Math;
using namespace Dew::Math::Units::Math387;
using namespace Dew::Signal;
using namespace Dew::Signal::Units::OptimalFir;
using namespace Dew::Signal::Units::SignalUtils;

void Example()
{
    Vector H(0);
    Vector Response(0);

    //Assumed sampling frequency = 2
    double FS = 2;
    double TransBW = 0.02; //transition bandwidth in Hz.
    double Ripple = 0.001;
    //Lowpass filter
    RemezImpulse(H, DewArray<double>{0.3, 0.3+TransBW}, Ripple, TFilterType::ftLowpass, 1, FS, false);
    //Highpass filter
    RemezImpulse(H, DewArray<double>{0.3, 0.3+TransBW}, Ripple, TFilterType::ftHighpass, 1, FS, false);
    //Bandpass filter
    RemezImpulse(H, DewArray<double>{0.3, 0.3+TransBW, 0.5-TransBW, 0.5}, Ripple, TFilterType::ftBandpass, 1, FS, false);
    //Bandstop filter
    RemezImpulse(H, DewArray<double>{0.3, 0.3+TransBW, 0.5-TransBW, 0.5}, Ripple, TFilterType::ftBandstop, 1, FS, false);


    //  Type III Hilbert transformer
    RemezImpulse(H, DewArray<double>{TransBW, 1-TransBW}, Ripple, TFilterType::ftHilbertIII, 1, FS, false);

    //  Type IV Hilbert transformer
    RemezImpulse(H, DewArray<double>{TransBW, 1}, Ripple, TFilterType::ftHilbertIV, 1, FS, false);

    //  Type III linear phase differentiator filter
    KaiserImpulse(H, DewArray<double>{1-TransBW, 1}, Ripple, TFilterType::ftDifferentiatorIII, 1, FS, false);
    H.Scale(FS);  //Scale by sampling frequency

    //  Type IV linear phase differentiator filter
    KaiserImpulse(H, DewArray<double>{1-TransBW, 1}, Ripple, TFilterType::ftDifferentiatorIV, 1, FS, false);
    H.Scale(FS);  //Scale by sampling frequency

    //  Type III differentiator filter
    RemezImpulse(H, DewArray<double>{0, 1-TransBW}, Ripple, TFilterType::ftDifferentiatorIII, 1, FS, false);
    H.Scale(FS);  //Scale by sampling frequency

    //  Type IV differentiator filter
    RemezImpulse(H, DewArray<double>{0, 1-TransBW}, Ripple, TFilterType::ftDifferentiatorIV, 1, FS, false);
    H.Scale(FS);  //Scale by sampling frequency

    // Type III 2x differentiator filter (remez)
    RemezImpulse(H, DewArray<double>{0, 1-TransBW}, Ripple, TFilterType::ftDoubleDifferentiatorIII, 1, FS, false);
    H.Scale(FS*FS);  //Scale by sampling frequency

    // Type IV 2x differentiator filter (remez)
    RemezImpulse(H, DewArray<double>{0, 1-TransBW}, Ripple, TFilterType::ftDoubleDifferentiatorIV, 1, FS, false);
    H.Scale(FS*FS);  //Scale by sampling frequency

    // Type III integrator  filter (remez).';
    RemezImpulse(H, DewArray<double>{TransBW, 1-TransBW}, Ripple, TFilterType::ftIntegratorIII, 1, FS, false);
    H.Scale(1/FS);  //Scale by sampling frequency

    // Type IV integrator  filter (remez).';
    RemezImpulse(H, DewArray<double>{TransBW, 1}, Ripple, TFilterType::ftIntegratorIV, 1, FS, false);
    H.Scale(1/FS);  //Scale by sampling frequency

    //  Type III 2x integrator  filter (remez).';
    RemezImpulse(H, DewArray<double>{TransBW, 1-TransBW}, Ripple, TFilterType::ftDoubleIntegratorIII, 1, FS, false);
    H.Scale(Sqr(1/FS));  //Scale by sampling frequency

    //  Type IV 2x integrator  filter (remez).';
    RemezImpulse(H, DewArray<double>{TransBW, 1}, Ripple, TFilterType::ftDoubleIntegratorIV, 1, FS, false);
    H.Scale(Sqr(1/FS));  //Scale by sampling frequency

    FrequencyResponse(H, nullptr, Response, 16, false, TSignalWindowType::wtRectangular, 0);
}

See Also: KaiserImpulse, SavGolayImpulse, OptimalFir::remez, FirImpulse

Declared in Dew::Signal::Units::OptimalFir · Dew.Signal/Units.OptimalFIR.h · Cross-compiler