Skip to content

Module_SignalProcessing_Filters

Jump to bottom
cyclone_dll edited this page Oct 2, 2026 · 11 revisions

Location: Home / Signal processing / Filters

Signal Processing Module

Filters

The Vorcyc.Mathematics.SignalProcessing.Filters namespace includes 1D filters: adaptive (LmfFilter, LmsFilter, NlmfFilter, NlmsFilter, RlsFilter, etc.), base types (FilterChain, FirFilter, IirFilter, StereoFilter, etc.), Bessel, biquad, Butterworth, Chebyshev, elliptic, FIR design (Fda), one-pole, polyphase, comb, DC removal, de-emphasis, Hilbert, median, moving average, pre-emphasis, RASTA, Savitzky–Golay, Thiran, and Wiener filters.

0.10.18: Filter kernels, FDA, and analog prototypes have a T track (float / double) alongside the existing float types. new IirFilter(IEnumerable<double>, …) / FirFilter(IEnumerable<double>) / ZiFilter(IEnumerable<double>, …) still cast to float — use the generic / *64 types to keep precision.

Vorcyc.Mathematics.SignalProcessing.Filters.Base.IirFilter<T> / IirFilter64

IirFilter<T> implements the same delay-line difference equation as IirFilter, for float and double only (IOnlineFilter<T>). IirFilter64 is IirFilter<double>.

var tf = DesignFilter.IirLpTf(0.1, PrototypeButterworth.Poles<double>(4));
var f64 = new IirFilter<double>(tf);
double[] y = f64.ApplyTo(x);

Vorcyc.Mathematics.SignalProcessing.Filters.Base.TransferFunction<T>

Coefficients, zpk (Zeros / Poles / ZpToTf / TfToZp), StateSpace / StateSpace<T>, Zi, ImpulseResponse, FrequencyResponse (Fft<T>), GroupDelay / PhaseDelay, Normalize / NormalizeAt, series / parallel * / +.

0.10.20: empty / null zpk → identity [1]. All-pole new TransferFunction([], poles, gain) is valid.

Vorcyc.Mathematics.SignalProcessing.Filters.Base.FirFilter<T> / ZiFilter<T>

FirFilter<T> is the delay-line FIR kernel; ZiFilter<T> keeps a state vector and ZeroPhase (filtfilt). FirFilter64 / ZiFilter64 are the double aliases.

FDA in T

DesignFilter.IirLpTf<T> / IirHpTf / IirBpTf / IirBsTf, notch / peak / comb, SOS, FirWin* / Fir / FirEquiripple* / Remez<T>. Prototypes: PrototypeButterworth.Poles<T>, Chebyshev I/II, elliptic, Bessel. Designed wrappers (Butterworth.LowPassFilter<T>, BiQuad / OnePole cookbook, …) inherit ZiFilter<T> or IirFilter<T>.

Gain normalisation of the pole-filter designs: low-pass at DC, high-pass at Nyquist, band-stop at DC, and band-pass at the image of the prototype's DC, the pre-warped geometric centre 2*atan(sqrt(tan(pi*fLow) * tan(pi*fHigh))) (not the arithmetic centre of the edges, which was used before 0.10.24). Chebyshev I / elliptic designs of even order therefore have unit gain at that point, where SciPy / MATLAB have 10^(-Rp/20).

All types below are in namespace: Vorcyc.Mathematics.SignalProcessing.Filters

📒 Contents

All types below are in namespace: Vorcyc.Mathematics.SignalProcessing.Filters.Adaptive

Vorcyc.Mathematics.SignalProcessing.Filters.Adaptive.LmfFilter class

Vorcyc.Mathematics.SignalProcessing.Filters.Adaptive.LmfFilter implements the least-mean-fourth (LMF) adaptive filtering algorithm.

Properties

1. Mu

  • private readonly float _mu
    • Gets or sets filter step size.

2. Leakage

  • private readonly float _leakage
    • Gets or sets filter leakage factor.

Methods

1. Constructor

  • public LmfFilter(int order, float mu = 0.75f, float leakage = 0)
    • Constructs LmfFilter with given order.
    • Parameters:
      • order: filterorder.
      • mu: step size, default 0.75.
      • leakage: leakage factor, default 0.

2. Process

  • public override float Process(float input, float desired)
    • Processes one input/desired sample and adaptively updates filter coefficients.
    • Parameters:
      • input: input signal sample..
      • desired: desired signal sample..
    • Returns: filter output sample.

Code example

The following example uses LmfFilter with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Filters.Adaptive;

public class LmfFilterExample
{
    public static void Main()
    {
        // Define filter order, step size, and leakage factor
        int order = 4;
        float mu = 0.75f;
        float leakage = 0.01f;

        // Create LmfFilter instance
        LmfFilter filter = new LmfFilter(order, mu, leakage);

        // Define input and desired signals
        float[] inputSignal = { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f };
        float[] desiredSignal = { 1.5f, 2.5f, 3.5f, 4.5f, 5.5f };

        // Process signal and print result
        for (int i = 0; i < inputSignal.Length; i++)
        {
            float output = filter.Process(inputSignal[i], desiredSignal[i]);
            Console.WriteLine($"Input: {inputSignal[i]}, Desired: {desiredSignal[i]}, Output: {output}");
        }
    }
}

Vorcyc.Mathematics.SignalProcessing.Filters.Adaptive.LmsFilter class

Vorcyc.Mathematics.SignalProcessing.Filters.Adaptive.LmsFilter implements the least mean square (Least-Mean-Squares) adaptive filtering algorithm.

Properties

1. Mu

  • private readonly float _mu
    • Gets or sets filter step size.

2. Leakage

  • private readonly float _leakage
    • Gets or sets filter leakage factor.

Methods

1. Constructor

  • public LmsFilter(int order, float mu = 0.75f, float leakage = 0)
    • Constructs LmsFilter with given order.
    • Parameters:
      • order: filterorder.
      • mu: step size, default 0.75.
      • leakage: leakage factor, default 0.

2. Process

  • public override float Process(float input, float desired)
    • Processes one input/desired sample and adaptively updates filter coefficients.
    • Parameters:
      • input: input signal sample..
      • desired: desired signal sample..
    • Returns: filter output sample.

Code example

The following example uses LmsFilter with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Filters.Adaptive;

public class LmsFilterExample
{
    public static void Main()
    {
        // Define filter order, step size, and leakage factor
        int order = 4;
        float mu = 0.75f;
        float leakage = 0.01f;

        // Create LmsFilter instance
        LmsFilter filter = new LmsFilter(order, mu, leakage);

        // Define input and desired signals
        float[] inputSignal = { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f };
        float[] desiredSignal = { 1.5f, 2.5f, 3.5f, 4.5f, 5.5f };

        // Process signal and print result
        for (int i = 0; i < inputSignal.Length; i++)
        {
            float output = filter.Process(inputSignal[i], desiredSignal[i]);
            Console.WriteLine($"Input: {inputSignal[i]}, Desired: {desiredSignal[i]}, Output: {output}");
        }
    }
}

Vorcyc.Mathematics.SignalProcessing.Filters.Adaptive.NlmfFilter class

Vorcyc.Mathematics.SignalProcessing.Filters.Adaptive.NlmfFilter implements the normalized least-mean-fourth (NLMF) adaptive filtering algorithm.

Properties

1. Mu

  • private readonly float _mu
    • Gets or sets filter step size.

2. Eps

  • private readonly float _eps
    • Gets or sets filter normalization factor.

3. Leakage

  • private readonly float _leakage
    • Gets or sets filter leakage factor.

Methods

1. Constructor

  • public NlmfFilter(int order, float mu = 0.75f, float eps = 1, float leakage = 0)
    • Constructs NlmfFilter with given order.
    • Parameters:
      • order: filterorder.
      • mu: step size, default 0.75.
      • eps: normalization factor; default 1..
      • leakage: leakage factor, default 0.

2. Process

  • public override float Process(float input, float desired)
    • Processes one input/desired sample and adaptively updates filter coefficients.
    • Parameters:
      • input: input signal sample..
      • desired: desired signal sample..
    • Returns: filter output sample.

Code example

The following example uses NlmfFilter with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Filters.Adaptive;

public class NlmfFilterExample
{
    public static void Main()
    {
        // Define filter order, step size, normalization factor, and leakage factor
        int order = 4;
        float mu = 0.75f;
        float eps = 1.0f;
        float leakage = 0.01f;

        // Create NlmfFilter instance
        NlmfFilter filter = new NlmfFilter(order, mu, eps, leakage);

        // Define input and desired signals
        float[] inputSignal = { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f };
        float[] desiredSignal = { 1.5f, 2.5f, 3.5f, 4.5f, 5.5f };

        // Process signal and print result
        for (int i = 0; i < inputSignal.Length; i++)
        {
            float output = filter.Process(inputSignal[i], desiredSignal[i]);
            Console.WriteLine($"Input: {inputSignal[i]}, Desired: {desiredSignal[i]}, Output: {output}");
        }
    }
}

Vorcyc.Mathematics.SignalProcessing.Filters.Adaptive.NlmsFilter class

Vorcyc.Mathematics.SignalProcessing.Filters.Adaptive.NlmsFilter implements the normalized least mean square (Normalized Least-Mean-Squares) adaptive filtering algorithm.

Properties

1. Mu

  • private readonly float _mu
    • Gets or sets filter step size.

2. Eps

  • private readonly float _eps
    • Gets or sets filter normalization factor.

3. Leakage

  • private readonly float _leakage
    • Gets or sets filter leakage factor.

Methods

1. Constructor

  • public NlmsFilter(int order, float mu = 0.75f, float eps = 1, float leakage = 0)
    • Constructs NlmsFilter with given order.
    • Parameters:
      • order: filterorder.
      • mu: step size, default 0.75.
      • eps: normalization factor; default 1..
      • leakage: leakage factor, default 0.

2. Process

  • public override float Process(float input, float desired)
    • Processes one input/desired sample and adaptively updates filter coefficients.
    • Parameters:
      • input: input signal sample..
      • desired: desired signal sample..
    • Returns: filter output sample.

Code example

The following example uses NlmsFilter with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Filters.Adaptive;

public class NlmsFilterExample
{
    public static void Main()
    {
        // Define filter order, step size, normalization factor, and leakage factor
        int order = 4;
        float mu = 0.75f;
        float eps = 1.0f;
        float leakage = 0.01f;

        // Create NlmsFilter instance
        NlmsFilter filter = new NlmsFilter(order, mu, eps, leakage);

        // Define input and desired signals
        float[] inputSignal = { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f };
        float[] desiredSignal = { 1.5f, 2.5f, 3.5f, 4.5f, 5.5f };

        // Process signal and print result
        for (int i = 0; i < inputSignal.Length; i++)
        {
            float output = filter.Process(inputSignal[i], desiredSignal[i]);
            Console.WriteLine($"Input: {inputSignal[i]}, Desired: {desiredSignal[i]}, Output: {output}");
        }
    }
}

Vorcyc.Mathematics.SignalProcessing.Filters.Adaptive.RlsFilter class

Vorcyc.Mathematics.SignalProcessing.Filters.Adaptive.RlsFilter implements the recursive least squares (Recursive-Least-Squares) adaptive filtering algorithm.

Properties

1. Lambda

  • private readonly float _lambda
    • Gets or sets filter forgetting factor.

2. InverseCorrMatrix

  • private readonly float[,] _p
    • Gets or sets filter inverse correlation matrix.

3. Gains

  • private readonly float[] _gains
    • Gets or sets filter gain coefficient matrix.

4. TemporaryMatrices

  • private readonly float[,] _dp, _tmp
    • Gets or sets temporary matrix for filter computation.

Methods

1. Constructor

  • public RlsFilter(int order, float lambda = 0.99f, float initCorrMatrix = 1e2f)
    • Constructs RlsFilter with given order.
    • Parameters:
      • order: filterorder.
      • lambda: forgetting factor; default 0.99..
      • initCorrMatrix: initial inverse correlation matrix value; default 1e2f..

2. Process

  • public override float Process(float input, float desired)
    • Processes one input/desired sample and adaptively updates filter coefficients.
    • Parameters:
      • input: input signal sample..
      • desired: desired signal sample..
    • Returns: filter output sample.

Code example

The following example uses RlsFilter with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Filters.Adaptive;

public class RlsFilterExample
{
    public static void Main()
    {
        // Define filter order, forgetting factor, and initial inverse correlation matrix value
        int order = 4;
        float lambda = 0.99f;
        float initCorrMatrix = 1e2f;

        // Create RlsFilter instance
        RlsFilter filter = new RlsFilter(order, lambda, initCorrMatrix);

        // Define input and desired signals
        float[] inputSignal = { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f };
        float[] desiredSignal = { 1.5f, 2.5f, 3.5f, 4.5f, 5.5f };

        // Process signal and print result
        for (int i = 0; i < inputSignal.Length; i++)
        {
            float output = filter.Process(inputSignal[i], desiredSignal[i]);
            Console.WriteLine($"Input: {inputSignal[i]}, Desired: {desiredSignal[i]}, Output: {output}");
        }
    }
}

Vorcyc.Mathematics.SignalProcessing.Filters.Adaptive.SignLmsFilter class

Vorcyc.Mathematics.SignalProcessing.Filters.Adaptive.SignLmsFilter implements the sign least-mean-squares adaptive filtering algorithm.

Properties

1. Mu

  • private readonly float _mu
    • Gets or sets filter step size.

2. Leakage

  • private readonly float _leakage
    • Gets or sets filter leakage factor.

Methods

1. Constructor

  • public SignLmsFilter(int order, float mu = 0.75f, float leakage = 0)
    • Constructs SignLmsFilter with given order.
    • Parameters:
      • order: filterorder.
      • mu: step size, default 0.75.
      • leakage: leakage factor, default 0.

2. Process

  • public override float Process(float input, float desired)
    • Processes one input/desired sample and adaptively updates filter coefficients.
    • Parameters:
      • input: input signal sample..
      • desired: desired signal sample..
    • Returns: filter output sample.

Code example

The following example uses SignLmsFilter with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Filters.Adaptive;

public class SignLmsFilterExample
{
    public static void Main()
    {
        // Define filter order, step size, and leakage factor
        int order = 4;
        float mu = 0.75f;
        float leakage = 0.01f;

        // Create SignLmsFilter instance
        SignLmsFilter filter = new SignLmsFilter(order, mu, leakage);

        // Define input and desired signals
        float[] inputSignal = { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f };
        float[] desiredSignal = { 1.5f, 2.5f, 3.5f, 4.5f, 5.5f };

        // Process signal and print result
        for (int i = 0; i < inputSignal.Length; i++)
        {
            float output = filter.Process(inputSignal[i], desiredSignal[i]);
            Console.WriteLine($"Input: {inputSignal[i]}, Desired: {desiredSignal[i]}, Output: {output}");
        }
    }
}

Vorcyc.Mathematics.SignalProcessing.Filters.Adaptive.VariableStepLmsFilter class

Vorcyc.Mathematics.SignalProcessing.Filters.Adaptive.VariableStepLmsFilter implements LMS adaptive filtering with variable step size.

Properties

1. Mu

  • private readonly float[] _mu
    • Gets or sets filter step-size array.

2. Leakage

  • private readonly float _leakage
    • Gets or sets filter leakage factor.

Methods

1. Constructor

  • public VariableStepLmsFilter(int order, float[] mu = null, float leakage = 0)
    • Constructs VariableStepLmsFilter with given order.
    • Parameters:
      • order: filterorder.
      • mu: step-size array; default 0.75 per order..
      • leakage: leakage factor, default 0.

2. Process

  • public override float Process(float input, float desired)
    • Processes one input/desired sample and adaptively updates filter coefficients.
    • Parameters:
      • input: input signal sample..
      • desired: desired signal sample..
    • Returns: filter output sample.

Code example

The following example uses VariableStepLmsFilter with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Filters.Adaptive;

public class VariableStepLmsFilterExample
{
    public static void Main()
    {
        // Define filter order, step-size array, and leakage factor
        int order = 4;
        float[] mu = { 0.75f, 0.8f, 0.85f, 0.9f };
        float leakage = 0.01f;

        // Create VariableStepLmsFilter instance
        VariableStepLmsFilter filter = new VariableStepLmsFilter(order, mu, leakage);

        // Define input and desired signals
        float[] inputSignal = { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f };
        float[] desiredSignal = { 1.5f, 2.5f, 3.5f, 4.5f, 5.5f };

        // Process signal and print result
        for (int i = 0; i < inputSignal.Length; i++)
        {
            float output = filter.Process(inputSignal[i], desiredSignal[i]);
            Console.WriteLine($"Input: {inputSignal[i]}, Desired: {desiredSignal[i]}, Output: {output}");
        }
    }
}

All types below are in namespace: Vorcyc.Mathematics.SignalProcessing.Filters.Base

Vorcyc.Mathematics.SignalProcessing.Filters.Base.FilterChain class

Vorcyc.Mathematics.SignalProcessing.Filters.Base.FilterChain implements serial filter chain.

Properties

1. Filters

  • private readonly List<IOnlineFilter> _filters
    • Gets or sets filter list in chain.

Methods

1. Constructor

  • public FilterChain(IEnumerable<IOnlineFilter> filters = null)

    • constructs FilterChain from online filter collection.
    • Parameters:
      • filters: online filter collection; default empty..

  • public FilterChain(IEnumerable<TransferFunction> tfs)

    • Constructs FilterChain from transfer function set (e.g. SOS sections); creates IirFilter objects internally.
    • Parameters:
      • tfs: transfer function set..

2. Add

  • public void Add(IOnlineFilter filter)
    • Adds filter to chain.
    • Parameters:
      • filter: Onlinefilter.

3. Insert

  • public void Insert(int index, IOnlineFilter filter)
    • Inserts filter at specified index in chain.
    • Parameters:
      • index: filter index in chain..
      • filter: Onlinefilter.

4. RemoveAt

  • public void RemoveAt(int index)
    • Removes filter at specified index from chain.
    • Parameters:
      • index: filter index in chain..

5. Process

  • public float Process(float sample)
    • Processes one sample through filter chain.
    • Parameters:
      • sample: input sample.
    • Returns: processed sample.

6. Reset

  • public void Reset()
    • Resets all filters in chain.

7. ApplyTo

  • public DiscreteSignal ApplyTo(DiscreteSignal signal, FilteringMethod method = FilteringMethod.Auto)
    • Applies filter to entire signal and returns new filtered signal.
    • Parameters:
      • signal: input signal.
      • method: filtering method; default FilteringMethod.Auto..
    • Returns: processed DiscreteSignal.

Code example

The following example uses FilterChain with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Filters.Base;

public class FilterChainExample
{
    public static void Main()
    {
        // example filters
        IOnlineFilter filter1 = new LowPassFilter(0.5f);
        IOnlineFilter filter2 = new HighPassFilter(0.2f);

        // create `FilterChain` and add filters
        FilterChain filterChain = new FilterChain();
        filterChain.Add(filter1);
        filterChain.Add(filter2);

        // Define input signal
        float[] inputSignal = { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f };

        // Process signal and print result
        foreach (var sample in inputSignal)
        {
            float output = filterChain.Process(sample);
            Console.WriteLine($"Input: {sample}, Output: {output}");
        }

        // Reset filter chain
        filterChain.Reset();
    }
}

Vorcyc.Mathematics.SignalProcessing.Filters.Base.FirFilter class

Vorcyc.Mathematics.SignalProcessing.Filters.Base.FirFilter implements a finite impulse response (FIR) filter.

Properties

1. Kernel

  • public float[] Kernel
    • Gets copy of filter kernel (impulse response).

2. Tf

  • public override TransferFunction Tf { get; protected set; }
    • Gets or sets filter transfer function.

3. KernelSizeForBlockConvolution

  • public int KernelSizeForBlockConvolution { get; set; } = 64
    • Gets or sets minimum kernel length to switch to overlap-save in auto mode.

Methods

1. Constructor

  • public FirFilter(IEnumerable<float> kernel)

    • constructs FirFilter from given kernel.
    • Parameters:
      • kernel: FIR filter kernel.

  • public FirFilter(IEnumerable<double> kernel)

    • constructs FirFilter from 64-bit kernel.
    • Parameters:
      • kernel: FIR filter kernel.

  • public FirFilter(TransferFunction tf)

    • constructs FirFilter from transfer function.
    • Parameters:
      • tf: transfer function.

2. ApplyTo

  • public override DiscreteSignal ApplyTo(DiscreteSignal signal, FilteringMethod method = FilteringMethod.Auto)
    • Applies filter to entire signal and returns new filtered signal.
    • Parameters:
      • signal: input signal.
      • method: filtering method; default FilteringMethod.Auto..
    • Returns: processed DiscreteSignal.

3. Process

  • public override float Process(float sample)
    • Processes one sample.
    • Parameters:
      • sample: input sample.
    • Returns: processed sample.

4. ProcessAllSamples

  • public float[] ProcessAllSamples(float[] samples)

    • processes all samples.
    • Parameters:
      • samples: sample array..
    • Returns: processed sample array.

  • public float[] ProcessAllSamples(Span<float> samples)

    • processes all samples.
    • Parameters:
      • samples: sample array..
    • Returns: processed sample array.

5. ApplyFilterDirectly

  • protected DiscreteSignal ApplyFilterDirectly(DiscreteSignal signal)
    • applies filter directly.
    • Parameters:
      • signal: input signal.
    • Returns: processed DiscreteSignal.

6. ChangeKernel

  • public void ChangeKernel(float[] kernel)
    • changes filter kernel.
    • Parameters:
      • kernel: New kernel.

7. Reset

  • public override void Reset()
    • Resetsfilter.

8.. Operator overloads

  • public static FirFilter operator *(FirFilter filter1, FirFilter filter2)

    • creates series connection of two FIR filters.
    • Parameters:
      • filter1: first FIR filter..
      • filter2: second FIR filter..
    • Returns: series-connected FIR filter.

  • public static IirFilter operator *(FirFilter filter1, IirFilter filter2)

    • creates series connection of FIR and IIR filters.
    • Parameters:
      • filter1: FIR filter.
      • filter2: IIR filter.
    • Returns: series-connected IIR filter.

  • public static FirFilter operator +(FirFilter filter1, FirFilter filter2)

    • creates parallel connection of two FIR filters.
    • Parameters:
      • filter1: first FIR filter..
      • filter2: second FIR filter..
    • Returns: parallel-connected FIR filter.

  • public static IirFilter operator +(FirFilter filter1, IirFilter filter2)

    • creates parallel connection of FIR and IIR filters.
    • Parameters:
      • filter1: FIR filter.
      • filter2: IIR filter.
    • Returns: parallel-connected IIR filter.

Code example

The following example uses FirFilter with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Filters.Base;

public class FirFilterExample
{
    public static void Main()
    {
        // Define filter kernel
        float[] kernel = { 0.2f, 0.2f, 0.2f, 0.2f, 0.2f };

        // Create FirFilter instance
        FirFilter filter = new FirFilter(kernel);

        // Define input signal
        float[] inputSignal = { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f };

        // Process signal and print result
        foreach (var sample in inputSignal)
        {
            float output = filter.Process(sample);
            Console.WriteLine($"Input: {sample}, Output: {output}");
        }

        // Reset filter
        filter.Reset();
    }
}

Vorcyc.Mathematics.SignalProcessing.Filters.Base.IirFilter class

Vorcyc.Mathematics.SignalProcessing.Filters.Base.IirFilter implements a infinite impulse response (IIR) filter.

Properties

1. Tf

  • public override TransferFunction Tf { get; protected set; }
    • Gets or sets filter transfer function.

2. DefaultImpulseResponseLength

  • public int DefaultImpulseResponseLength { get; set; } = 512
    • Gets or sets default truncated impulse response length.

Methods

1. Constructor

  • public IirFilter(IEnumerable<float> b, IEnumerable<float> a)

    • constructs IirFilter from numerator and denominator coefficients.
    • Parameters:
      • b: transfer function numerator coefficients..
      • a: transfer function denominator coefficients..

  • public IirFilter(IEnumerable<double> b, IEnumerable<double> a)

    • constructs IirFilter from 64-bit numerator/denominator coefficients.
    • Parameters:
      • b: transfer function numerator coefficients..
      • a: transfer function denominator coefficients..

  • public IirFilter(TransferFunction tf)

    • constructs IirFilter from transfer function.
    • Parameters:
      • tf: transfer function.

2. ApplyTo

  • public override DiscreteSignal ApplyTo(DiscreteSignal signal, FilteringMethod method = FilteringMethod.Auto)
    • Applies filter to entire signal and returns new filtered signal.
    • Parameters:
      • signal: input signal.
      • method: filtering method; default FilteringMethod.Auto..
    • Returns: processed DiscreteSignal.

3. Process

  • public override float Process(float sample)
    • Processes one sample.
    • Parameters:
      • sample: input sample.
    • Returns: processed sample.

4. ApplyFilterDirectly

  • protected DiscreteSignal ApplyFilterDirectly(DiscreteSignal signal)
    • applies filter directly.
    • Parameters:
      • signal: input signal.
    • Returns: processed DiscreteSignal.

5. ChangeNumeratorCoeffs

  • public void ChangeNumeratorCoeffs(float[] b)
    • Changes filter numerator coefficients.
    • Parameters:
      • b: new numerator coefficients..

6. ChangeDenominatorCoeffs

  • public void ChangeDenominatorCoeffs(float[] a)
    • Changes filter denominator coefficients.
    • Parameters:
      • a: new denominator coefficients..

7. Change

  • public void Change(TransferFunction tf)
    • Changes filter transfer function.
    • Parameters:
      • tf: new transfer function..

8. Reset

  • public override void Reset()
    • Resetsfilter.

9. Normalize

  • public void Normalize()
    • Normalizes transfer function (divides all coefficients by the first denominator coefficient).

10.. Operator overloads

  • public static IirFilter operator *(IirFilter filter1, LtiFilter filter2)

    • creates series connection of IIR and arbitrary LTI filter.
    • Parameters:
      • filter1: IIR filter.
      • filter2: LTI filter.
    • Returns: series-connected IIR filter.

  • public static IirFilter operator +(IirFilter filter1, LtiFilter filter2)

    • creates parallel connection of IIR and arbitrary LTI filter.
    • Parameters:
      • filter1: IIR filter.
      • filter2: LTI filter.
    • Returns: parallel-connected IIR filter.

Code example

The following example uses IirFilter with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Filters.Base;

public class IirFilterExample
{
    public static void Main()
    {
        // Define filter numerator and denominator coefficients
        float[] b = { 0.2f, 0.2f, 0.2f, 0.2f, 0.2f };
        float[] a = { 1.0f, -0.5f, 0.25f, -0.125f, 0.0625f };

        // Create IirFilter instance
        IirFilter filter = new IirFilter(b, a);

        // Define input signal
        float[] inputSignal = { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f };

        // Process signal and print result
        foreach (var sample in inputSignal)
        {
            float output = filter.Process(sample);
            Console.WriteLine($"Input: {sample}, Output: {output}");
        }

        // Reset filter
        filter.Reset();
    }
}

Vorcyc.Mathematics.SignalProcessing.Filters.Base.StereoFilter class

Vorcyc.Mathematics.SignalProcessing.Filters.Base.StereoFilter filters interleaved stereo buffer data. It contains two independent filters: one for the left channel and one for the right channel.

Properties

1. FilterLeft

  • private readonly IOnlineFilter _filterLeft
    • Gets or sets left-channel filter.

2. FilterRight

  • private readonly IOnlineFilter _filterRight
    • Gets or sets right-channel filter.

3. IsRight

  • private bool _isRight
    • internal flag toggling left/right channel.

Methods

1. Constructor

  • public StereoFilter(IOnlineFilter filterLeft, IOnlineFilter filterRight)
    • constructs StereoFilter from two independent filters.
    • Parameters:
      • filterLeft: left-channel filter..
      • filterRight: right-channel filter..

2. Process

  • public float Process(float sample)
    • Processes one sample.
    • Parameters:
      • sample: input sample.
    • Returns: processed sample.

3. Reset

  • public void Reset()
    • Resetsfilter.

4. ApplyTo

  • public DiscreteSignal ApplyTo(DiscreteSignal signal, FilteringMethod method = FilteringMethod.Auto)
    • Applies filter to entire signal and returns new filtered signal.
    • Parameters:
      • signal: input signal.
      • method: filtering method; default FilteringMethod.Auto..
    • Returns: processed DiscreteSignal.

Code example

The following example uses StereoFilter with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Filters.Base;

public class StereoFilterExample
{
    public static void Main()
    {
        // example filters
        IOnlineFilter filterLeft = new LowPassFilter(0.5f);
        IOnlineFilter filterRight = new HighPassFilter(0.2f);

        // Create StereoFilter instance
        StereoFilter stereoFilter = new StereoFilter(filterLeft, filterRight);

        // Define input signal
        float[] inputSignal = { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f };

        // Process signal and print result
        foreach (var sample in inputSignal)
        {
            float output = stereoFilter.Process(sample);
            Console.WriteLine($"Input: {sample}, Output: {output}");
        }

        // Reset filter
        stereoFilter.Reset();
    }
}

Vorcyc.Mathematics.SignalProcessing.Filters.Base.TransferFunction class

Vorcyc.Mathematics.SignalProcessing.Filters.Base.TransferFunction is used for representing an LTI filter transfer function.

Properties

1. Numerator

  • public float[] Numerator { get; protected set; }
    • Gets transfer function numerator.

2. Denominator

  • public float[] Denominator { get; protected set; }
    • Gets transfer function denominator.

3. CalculateZpIterations

  • public int CalculateZpIterations { get; set; } = VMath.PolyRootsIterations
    • Gets or sets max iterations for zero/pole computation. Default 25000.

4. Zeros

  • public ComplexFp32[] Zeros => _zeros ?? TfToZp(Numerator, CalculateZpIterations)
    • Gets zeros ('z' in zpk notation).

5. Poles

  • public ComplexFp32[] Poles => _poles ?? TfToZp(Denominator, CalculateZpIterations)
    • Gets poles ('p' in zpk notation).

6. Gain

  • public float Gain => Numerator[0]
    • Gets gain ('k' in zpk notation).

7. StateSpace

  • public StateSpace StateSpace { get; }
    • Gets state-space representation.

8. Zi

  • public float[] Zi { get; }
    • Gets initial state corresponding to step-response steady state.

Methods

1. Constructor

  • public TransferFunction(float[] numerator, float[] denominator = null)

    • constructs TransferFunction from numerator and denominator.
    • Parameters:
      • numerator: transfer function numerator..
      • denominator: transfer function denominator; default [1.0f]..

  • public TransferFunction(ComplexFp32[] zeros, ComplexFp32[] poles, float gain = 1)

    • constructs TransferFunction from zeros, poles, and gain.
    • Parameters:
      • zeros: zeros.
      • poles: poles.
      • gain: gain, default 1.

  • public TransferFunction(ComplexDiscreteSignalFp32 zeros, ComplexDiscreteSignalFp32 poles, float gain = 1)

    • constructs TransferFunction from zeros, poles, and gain.
    • Parameters:
      • zeros: zeros.
      • poles: poles.
      • gain: gain, default 1.

  • public TransferFunction(StateSpace stateSpace)

    • constructs TransferFunction from state-space representation.
    • Parameters:
      • stateSpace: state-space representation..

2. ImpulseResponse

  • public float[] ImpulseResponse(int length = 512)
    • computes impulse response of given length.
    • Parameters:
      • length: impulse response length..
    • Returns: impulse response array.

3. FrequencyResponse

  • public ComplexDiscreteSignalFp32 FrequencyResponse(int length = 512)
    • computes frequency response of given length.
    • Parameters:
      • length: frequency response length..
    • Returns: ComplexDiscreteSignalFp32 of frequency response.

4. GroupDelay

  • public float[] GroupDelay(int length = 512)
    • computes group delay of given length.
    • Parameters:
      • length: group delay array length..
    • Returns: group delay array.

5. PhaseDelay

  • public float[] PhaseDelay(int length = 512)
    • computes phase delay of given length.
    • Parameters:
      • length: phase delay array length..
    • Returns: phase delay array.

6. NormalizeAt

  • public void NormalizeAt(float freq)
    • normalizes frequency response at given frequency (maps to [0, 1]).
    • Parameters:
      • freq: frequency.

7. Normalize

  • public void Normalize()
    • normalizes numerator and denominator (divide by first denominator coefficient).

8.. Operator overloads

  • public static TransferFunction operator *(TransferFunction tf1, TransferFunction tf2)

    • creates series connection of two transfer functions.
    • Parameters:
      • tf1: first transfer function..
      • tf2: second transfer function..
    • Returns: series-connected transfer function.

  • public static TransferFunction operator +(TransferFunction tf1, TransferFunction tf2)

    • creates parallel connection of two transfer functions.
    • Parameters:
      • tf1: first transfer function..
      • tf2: second transfer function..
    • Returns: parallel-connected transfer function.

9. FromCsv

  • public static TransferFunction FromCsv(Stream stream, char delimiter = ',')
    • loads transfer function numerator/denominator from CSV stream.
    • Parameters:
      • stream: Input stream.
      • delimiter: delimiter; default ,..
    • Returns: TransferFunction instance.

10. ToCsv

  • public void ToCsv(Stream stream, char delimiter = ',')
    • serializes transfer function numerator/denominator to CSV stream.
    • Parameters:
      • stream: Output stream.
      • delimiter: delimiter; default ,..

Code example

The following example uses TransferFunction with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Filters.Base;

public class TransferFunctionExample
{
    public static void Main()
    {
        // Define transfer function numerator and denominator
        float[] numerator = { 0.2f, 0.2f, 0.2f, 0.2f, 0.2f };
        float[] denominator = { 1.0f, -0.5f, 0.25f, -0.125f, 0.0625f };

        // Create TransferFunction instance
        TransferFunction tf = new TransferFunction(numerator, denominator);

        // Compute impulse response
        float[] impulseResponse = tf.ImpulseResponse();
        Console.WriteLine("Impulse Response:");
        foreach (var value in impulseResponse)
        {
            Console.WriteLine(value);
        }

        // Compute frequency response
        var frequencyResponse = tf.FrequencyResponse();
        Console.WriteLine("Frequency Response:");
        foreach (var value in frequencyResponse.Real)
        {
            Console.WriteLine(value);
        }

        // Computesgroup delay
        float[] groupDelay = tf.GroupDelay();
        Console.WriteLine("Group Delay:");
        foreach (var value in groupDelay)
        {
            Console.WriteLine(value);
        }

        // Compute phasedelay
        float[] phaseDelay = tf.PhaseDelay();
        Console.WriteLine("Phase Delay:");
        foreach (var value in phaseDelay)
        {
            Console.WriteLine(value);
        }

        // normalizedtransfer function
        tf.Normalize();
    }
}

Vorcyc.Mathematics.SignalProcessing.Filters.Base.ZiFilter class

Vorcyc.Mathematics.SignalProcessing.Filters.Base.ZiFilter is a state-vector-based LTI filter implementation. It allows setting initial state (filter delay initial conditions) and provides additional zero-phase filtering methods.

Properties

1. Zi

  • public float[] Zi => _zi
    • Gets state vector.

2. Tf

  • public override TransferFunction Tf { get; protected set; }
    • Gets or sets filter transfer function.

Methods

1. Constructor

  • public ZiFilter(IEnumerable<float> b, IEnumerable<float> a)

    • Constructs ZiFilter from numerator and denominator.
    • Parameters:
      • b: transfer function numerator..
      • a: transfer function denominator..

  • public ZiFilter(IEnumerable<double> b, IEnumerable<double> a)

    • Constructs ZiFilter from 64-bit numerator and denominator.
    • Parameters:
      • b: transfer function numerator..
      • a: transfer function denominator..

  • public ZiFilter(TransferFunction tf)

    • Constructs ZiFilter from transfer function.
    • Parameters:
      • tf: transfer function.

2. Init

  • public virtual void Init(float[] zi)

    • Uses initial conditionsInitializesfilter.
    • Parameters:
      • zi: initial condition vector..

  • public virtual void Init(double[] zi)

    • Uses initial conditionsInitializesfilter.
    • Parameters:
      • zi: initial condition vector..

3. Process

  • public override float Process(float sample)
    • Processes one sample.
    • Parameters:
      • sample: input sample.
    • Returns: processed sample.

4. ZeroPhase

  • public DiscreteSignal ZeroPhase(DiscreteSignal signal, int padLength = 0)
    • performs zero-phase filtering.
    • Parameters:
      • signal: input signal.
      • padLength: number of elements to pad at both ends before filtering.default 3 * (max{len(numerator), len(denominator)} - 1)..
    • Returns: processed DiscreteSignal.

5. ChangeNumeratorCoeffs

  • public void ChangeNumeratorCoeffs(float[] b)
    • Changes filter numerator coefficients.
    • Parameters:
      • b: new numerator coefficients..

6. ChangeDenominatorCoeffs

  • public void ChangeDenominatorCoeffs(float[] a)
    • Changes filter denominator coefficients.
    • Parameters:
      • a: new denominator coefficients..

7. Change

  • public void Change(TransferFunction tf)
    • Changes filter transfer function.
    • Parameters:
      • tf: new transfer function..

8. Reset

  • public override void Reset()
    • Resetsfilter.

9. ApplyTo

  • public override DiscreteSignal ApplyTo(DiscreteSignal signal, FilteringMethod method = FilteringMethod.Auto)
    • Applies filter to entire signal and returns new filtered signal.
    • Parameters:
      • signal: input signal.
      • method: filtering method; default FilteringMethod.Auto..
    • Returns: processed DiscreteSignal.

Code example

The following example uses ZiFilter with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Filters.Base;

public class ZiFilterExample
{
    public static void Main()
    {
        // Define filter numerator and denominator coefficients
        float[] b = { 0.2f, 0.2f, 0.2f, 0.2f, 0.2f };
        float[] a = { 1.0f, -0.5f, 0.25f, -0.125f, 0.0625f };

        // Create ZiFilter instance
        ZiFilter filter = new ZiFilter(b, a);

        // Define input signal
        float[] inputSignal = { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f };

        // Process signal and print result
        foreach (var sample in inputSignal)
        {
            float output = filter.Process(sample);
            Console.WriteLine($"Input: {sample}, Output: {output}");
        }

        // Perform zero-phase filtering
        var signal = new DiscreteSignal(44100, inputSignal);
        var zeroPhaseSignal = filter.ZeroPhase(signal);
        Console.WriteLine("Zero Phase Filtered Signal:");
        foreach (var sample in zeroPhaseSignal.Samples)
        {
            Console.WriteLine(sample);
        }

        // Reset filter
        filter.Reset();
    }
}

All types below are in namespace: Vorcyc.Mathematics.SignalProcessing.Filters.Bassel

Vorcyc.Mathematics.SignalProcessing.Filters.Bessel.BandPassFilter class

Vorcyc.Mathematics.SignalProcessing.Filters.Bessel.BandPassFilter implements a band-pass Bessel filter.

Properties

1. FrequencyLow

  • public float FrequencyLow { get; private set; }
    • Gets low cutoff frequency.

2. FrequencyHigh

  • public float FrequencyHigh { get; private set; }
    • Gets high cutoff frequency.

3. Order

  • public int Order => (_a.Length - 1) / 2
    • Getsfilterorder.

Methods

1. Constructor

  • public BandPassFilter(float frequencyLow, float frequencyHigh, int order)
    • Constructs with given order and cutoff frequency BandPassFilter instance.
    • Parameters:
      • frequencyLow: normalized low cutoff frequency, range [0..0.5]..
      • frequencyHigh: normalized high cutoff frequency, range [0..0.5]..
      • order: filterorder.

2. MakeTf

  • private static TransferFunction MakeTf(float frequencyLow, float frequencyHigh, int order)
    • Generates transfer function.
    • Parameters:
      • frequencyLow: normalized low cutoff frequency, range [0..0.5]..
      • frequencyHigh: normalized high cutoff frequency, range [0..0.5]..
      • order: filterorder.
    • Returns: generated TransferFunction.

3. Change

  • public void Change(float frequencyLow, float frequencyHigh)
    • changes filter coefficients (preserves filter state).
    • Parameters:
      • frequencyLow: normalized low cutoff frequency, range [0..0.5]..
      • frequencyHigh: normalized high cutoff frequency, range [0..0.5]..

Code example

The following example uses BandPassFilter with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Filters.Bessel;

public class BandPassFilterExample
{
    public static void Main()
    {
        // Define low/high cutoff frequencies and filter order
        float frequencyLow = 0.1f;
        float frequencyHigh = 0.3f;
        int order = 4;

        // Create BandPassFilter instance
        BandPassFilter filter = new BandPassFilter(frequencyLow, frequencyHigh, order);

        // Define input signal
        float[] inputSignal = { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f };

        // Process signal and print result
        foreach (var sample in inputSignal)
        {
            float output = filter.Process(sample);
            Console.WriteLine($"Input: {sample}, Output: {output}");
        }

        // Change filter cutoff frequency
        filter.Change(0.2f, 0.4f);

        // Process signal and print result
        foreach (var sample in inputSignal)
        {
            float output = filter.Process(sample);
            Console.WriteLine($"Input: {sample}, Output after change: {output}");
        }
    }
}

Vorcyc.Mathematics.SignalProcessing.Filters.Bessel.BandStopFilter class

Vorcyc.Mathematics.SignalProcessing.Filters.Bessel.BandStopFilter implements a band-stop Bessel filter.

Properties

1. FrequencyLow

  • public float FrequencyLow { get; private set; }
    • Gets low cutoff frequency.

2. FrequencyHigh

  • public float FrequencyHigh { get; private set; }
    • Gets high cutoff frequency.

3. Order

  • public int Order => (_a.Length - 1) / 2
    • Getsfilterorder.

Methods

1. Constructor

  • public BandStopFilter(float frequencyLow, float frequencyHigh, int order)
    • Constructs with given order and cutoff frequency BandStopFilter instance.
    • Parameters:
      • frequencyLow: normalized low cutoff frequency, range [0..0.5]..
      • frequencyHigh: normalized high cutoff frequency, range [0..0.5]..
      • order: filterorder.

2. MakeTf

  • private static TransferFunction MakeTf(float frequencyLow, float frequencyHigh, int order)
    • Generates transfer function.
    • Parameters:
      • frequencyLow: normalized low cutoff frequency, range [0..0.5]..
      • frequencyHigh: normalized high cutoff frequency, range [0..0.5]..
      • order: filterorder.
    • Returns: generated TransferFunction.

3. Change

  • public void Change(float frequencyLow, float frequencyHigh)
    • changes filter coefficients (preserves filter state).
    • Parameters:
      • frequencyLow: normalized low cutoff frequency, range [0..0.5]..
      • frequencyHigh: normalized high cutoff frequency, range [0..0.5]..

Code example

The following example uses BandStopFilter with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Filters.Bessel;

public class BandStopFilterExample
{
    public static void Main()
    {
        // Define low/high cutoff frequencies and filter order
        float frequencyLow = 0.1f;
        float frequencyHigh = 0.3f;
        int order = 4;

        // Create BandStopFilter instance
        BandStopFilter filter = new BandStopFilter(frequencyLow, frequencyHigh, order);

        // Define input signal
        float[] inputSignal = { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f };

        // Process signal and print result
        foreach (var sample in inputSignal)
        {
            float output = filter.Process(sample);
            Console.WriteLine($"Input: {sample}, Output: {output}");
        }

        // Change filter cutoff frequency
        filter.Change(0.2f, 0.4f);

        // Process signal and print result
        foreach (var sample in inputSignal)
        {
            float output = filter.Process(sample);
            Console.WriteLine($"Input: {sample}, Output after change: {output}");
        }
    }
}

Vorcyc.Mathematics.SignalProcessing.Filters.Bessel.HighPassFilter class

Vorcyc.Mathematics.SignalProcessing.Filters.Bessel.HighPassFilter implements a high-pass Bessel filter.

Properties

1. Frequency

  • public float Frequency { get; private set; }
    • Getscutoff frequency.

2. Order

  • public int Order => _a.Length - 1
    • Getsfilterorder.

Methods

1. Constructor

  • public HighPassFilter(float frequency, int order)
    • Constructs with given order and cutoff frequency HighPassFilter instance.
    • Parameters:
      • frequency: normalized cutoff frequency, range [0..0.5]..
      • order: filterorder.

2. MakeTf

  • private static TransferFunction MakeTf(float frequency, int order)
    • Generates transfer function.
    • Parameters:
      • frequency: normalized cutoff frequency, range [0..0.5]..
      • order: filterorder.
    • Returns: generated TransferFunction.

3. Change

  • public void Change(float frequency)
    • changes filter coefficients (preserves filter state).
    • Parameters:
      • frequency: normalized cutoff frequency, range [0..0.5]..

Code example

The following example uses HighPassFilter with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Filters.Bessel;

public class HighPassFilterExample
{
    public static void Main()
    {
        // Define cutoff frequency and filter order
        float frequency = 0.2f;
        int order = 4;

        // Create HighPassFilter instance
        HighPassFilter filter = new HighPassFilter(frequency, order);

        // Define input signal
        float[] inputSignal = { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f };

        // Process signal and print result
        foreach (var sample in inputSignal)
        {
            float output = filter.Process(sample);
            Console.WriteLine($"Input: {sample}, Output: {output}");
        }

        // Change filter cutoff frequency
        filter.Change(0.3f);

        // Process signal and print result
        foreach (var sample in inputSignal)
        {
            float output = filter.Process(sample);
            Console.WriteLine($"Input: {sample}, Output after change: {output}");
        }
    }
}

Vorcyc.Mathematics.SignalProcessing.Filters.Bessel.LowPassFilter class

Vorcyc.Mathematics.SignalProcessing.Filters.Bessel.LowPassFilter implements a low-pass Bessel filter.

Properties

1. Frequency

  • public float Frequency { get; private set; }
    • Getscutoff frequency.

2. Order

  • public int Order => _a.Length - 1
    • Getsfilterorder.

Methods

1. Constructor

  • public LowPassFilter(float frequency, int order)
    • Constructs with given order and cutoff frequency LowPassFilter instance.
    • Parameters:
      • frequency: normalized cutoff frequency, range [0..0.5]..
      • order: filterorder.

2. MakeTf

  • private static TransferFunction MakeTf(float frequency, int order)
    • Generates transfer function.
    • Parameters:
      • frequency: normalized cutoff frequency, range [0..0.5]..
      • order: filterorder.
    • Returns: generated TransferFunction.

3. Change

  • public void Change(float frequency)
    • changes filter coefficients (preserves filter state).
    • Parameters:
      • frequency: normalized cutoff frequency, range [0..0.5]..

Code example

The following example uses LowPassFilter with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Filters.Bessel;

public class LowPassFilterExample
{
    public static void Main()
    {
        // Define cutoff frequency and filter order
        float frequency = 0.2f;
        int order = 4;

        // Create LowPassFilter instance
        LowPassFilter filter = new LowPassFilter(frequency, order);

        // Define input signal
        float[] inputSignal = { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f };

        // Process signal and print result
        foreach (var sample in inputSignal)
        {
            float output = filter.Process(sample);
            Console.WriteLine($"Input: {sample}, Output: {output}");
        }

        // Change filter cutoff frequency
        filter.Change(0.3f);

        // Process signal and print result
        foreach (var sample in inputSignal)
        {
            float output = filter.Process(sample);
            Console.WriteLine($"Input: {sample}, Output after change: {output}");
        }
    }
}

Vorcyc.Mathematics.SignalProcessing.Filters.Bessel.PrototypeBessel class

Vorcyc.Mathematics.SignalProcessing.Filters.Bessel.PrototypeBessel generates Besselfilterprototype static class.

Methods

1. Reverse

  • public static float Reverse(int k, int n)
    • Gets k-th coefficient of n-th order Bessel polynomial.
    • Parameters:
      • k: coefficient index..
      • n: Bessel polynomial order..
    • Returns: k-th coefficient.

2. Poles

  • public static ComplexFp32[] Poles(int order)
    • computes analog poles of Bessel filter of given order.
    • Parameters:
      • order: filterorder.
    • Returns: pole array.

Code example

The following example uses PrototypeBessel with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Filters.Bessel;

public class PrototypeBesselExample
{
    public static void Main()
    {
        // Define Bessel polynomial order
        int order = 4;

        // Get Bessel polynomial coefficients
        for (int k = 0; k <= order; k++)
        {
            float coefficient = PrototypeBessel.Reverse(k, order);
            Console.WriteLine($"Coefficient k={k}, n={order}: {coefficient}");
        }

        // Compute Bessel filter poles
        var poles = PrototypeBessel.Poles(order);
        Console.WriteLine("Poles:");
        foreach (var pole in poles)
        {
            Console.WriteLine(pole);
        }
    }
}

All types below are in namespace: Vorcyc.Mathematics.SignalProcessing.Filters.BiQuad

Vorcyc.Mathematics.SignalProcessing.Filters.BiQuad.AllPassFilter class

Vorcyc.Mathematics.SignalProcessing.Filters.BiQuad.AllPassFilter implements a biquad all-pass filter.

Properties

1. Frequency

  • public float Frequency { get; protected set; }
    • Getscenter frequency.

2. Q

  • public float Q { get; protected set; }
    • Gets Q factor.

Methods

1. Constructor

  • public AllPassFilter(float frequency, float q = 1)
    • Constructs AllPassFilter instance.
    • Parameters:
      • frequency: normalized center frequency, range [0..0.5]..
      • q: Q factor; default 1..

2. SetCoefficients

  • private void SetCoefficients(float frequency, float q)
    • sets filter coefficients.
    • Parameters:
      • frequency: normalized center frequency, range [0..0.5]..
      • q: Q factor..

3. Change

  • public void Change(float frequency, float q = 1)
    • changes filter coefficients online (preserves state).
    • Parameters:
      • frequency: normalized center frequency, range [0..0.5]..
      • q: Q factor; default 1..

Code example

The following example uses AllPassFilter with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Filters.BiQuad;

public class AllPassFilterExample
{
    public static void Main()
    {
        // Define center frequency and Q factor
        float frequency = 0.2f;
        float q = 1.0f;

        // Create AllPassFilter instance
        AllPassFilter filter = new AllPassFilter(frequency, q);

        // Define input signal
        float[] inputSignal = { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f };

        // Process signal and print result
        foreach (var sample in inputSignal)
        {
            float output = filter.Process(sample);
            Console.WriteLine($"Input: {sample}, Output: {output}");
        }

        // Change filter center frequency and Q factor
        filter.Change(0.3f, 0.8f);

        // Process signal and print result
        foreach (var sample in inputSignal)
        {
            float output = filter.Process(sample);
            Console.WriteLine($"Input: {sample}, Output after change: {output}");
        }
    }
}

Vorcyc.Mathematics.SignalProcessing.Filters.BiQuad.BandPassFilter class

Vorcyc.Mathematics.SignalProcessing.Filters.BiQuad.BandPassFilter implements a biquad band-pass filter.

Properties

1. Frequency

  • public float Frequency { get; protected set; }
    • Getscenter frequency.

2. Q

  • public float Q { get; protected set; }
    • Gets Q factor.

Methods

1. BandPassFilter

  • public BandPassFilter(float frequency, float q = 1)
    • Constructs BandPassFilter instance.
    • Parameters:
      • frequency: normalized center frequency, range [0..0.5]..
      • q: Q factor; default 1..

2. SetCoefficients

  • private void SetCoefficients(float frequency, float q)
    • sets filter coefficients.
    • Parameters:
      • frequency: normalized center frequency, range [0..0.5]..
      • q: Q factor..

3. Change

  • public void Change(float frequency, float q = 1)
    • changes filter coefficients online (preserves state).
    • Parameters:
      • frequency: normalized center frequency, range [0..0.5]..
      • q: Q factor; default 1..

Code example

The following example uses BandPassFilter with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Filters.BiQuad;
public class BandPassFilterExample
{
    public static void Main()
    {
        // Define center frequency and Q factor
        float frequency = 0.2f;
        float q = 1.0f;

        // Create BandPassFilter instance
        BandPassFilter filter = new BandPassFilter(frequency, q);

        // Define input signal
        float[] inputSignal = { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f };

        // Process signal and print result
        foreach (var sample in inputSignal)
        {
            float output = filter.Process(sample);
            Console.WriteLine($"Input: {sample}, Output: {output}");
        }

        // Change filter center frequency and Q factor
        filter.Change(0.3f, 0.8f);

        // Process signal and print result
        foreach (var sample in inputSignal)
        {
            float output = filter.Process(sample);
            Console.WriteLine($"Input: {sample}, Output after change: {output}");
        }
    }
}

Vorcyc.Mathematics.SignalProcessing.Filters.BiQuad.BiQuadFilter class

Vorcyc.Mathematics.SignalProcessing.Filters.BiQuad.BiQuadFilter implements a biquad IIR filter.

Properties

No public properties.

Methods

1. Constructor

  • protected BiQuadFilter()

    • Constructs default BiQuadFilter with default coefficients.

  • public BiQuadFilter(float b0, float b1, float b2, float a0, float a1, float a2)

    • Constructs BiQuadFilter from coefficients (numerator {B0, B1, B2}, denominator {A0, A1, A2}).
    • Parameters:
      • b0: B0 coefficient.
      • b1: B1 coefficient.
      • b2: B2 coefficient.
      • a0: A0 coefficient.
      • a1: A1 coefficient.
      • a2: A2 coefficient.

2. Process

  • public override float Process(float sample)
    • Processes one sample.
    • Parameters:
      • sample: input sample.
    • Returns: processed sample.

3. Reset

  • public override void Reset()
    • Resetsfilter.

4. Change

  • public void Change(float b0, float b1, float b2, float a0, float a1, float a2)
    • changes filter coefficients online (preserves state).
    • Parameters:
      • b0: B0 coefficient.
      • b1: B1 coefficient.
      • b2: B2 coefficient.
      • a0: A0 coefficient.
      • a1: A1 coefficient.
      • a2: A2 coefficient.

Code example

The following example uses BiQuadFilter with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Filters.BiQuad;

public class BiQuadFilterExample
{
    public static void Main()
    {
        // Define filter numerator and denominator coefficients
        float b0 = 0.2f;
        float b1 = 0.2f;
        float b2 = 0.2f;
        float a0 = 1.0f;
        float a1 = -0.5f;
        float a2 = 0.25f;

        // Create BiQuadFilter instance
        BiQuadFilter filter = new BiQuadFilter(b0, b1, b2, a0, a1, a2);

        // Define input signal
        float[] inputSignal = { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f };

        // Process signal and print result
        foreach (var sample in inputSignal)
        {
            float output = filter.Process(sample);
            Console.WriteLine($"Input: {sample}, Output: {output}");
        }

        // Change filter coefficients
        filter.Change(0.3f, 0.3f, 0.3f, 1.0f, -0.4f, 0.2f);

        // Process signal and print result
        foreach (var sample in inputSignal)
        {
            float output = filter.Process(sample);
            Console.WriteLine($"Input: {sample}, Output after change: {output}");
        }

        // Reset filter
        filter.Reset();
    }
}

Vorcyc.Mathematics.SignalProcessing.Filters.BiQuad.HighPassFilter class

Vorcyc.Mathematics.SignalProcessing.Filters.BiQuad.HighPassFilter implements a biquad high-pass filter.

Properties

1. Frequency

  • public float Frequency { get; protected set; }
    • Getscutoff frequency.

2. Q

  • public float Q { get; protected set; }
    • Gets Q factor.

Methods

1. Constructor

  • public HighPassFilter(float frequency, float q = 1)
    • Constructs HighPassFilter instance.
    • Parameters:
      • frequency: normalized cutoff frequency, range [0..0.5]..
      • q: Q factor; default 1..

2. SetCoefficients

  • private void SetCoefficients(float frequency, float q)
    • sets filter coefficients.
    • Parameters:
      • frequency: normalized cutoff frequency, range [0..0.5]..
      • q: Q factor..

3. Change

  • public void Change(float frequency, float q = 1)
    • changes filter coefficients online (preserves state).
    • Parameters:
      • frequency: normalized cutoff frequency, range [0..0.5]..
      • q: Q factor; default 1..

Code example

The following example uses HighPassFilter with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Filters.BiQuad;

public class HighPassFilterExample
{
    public static void Main()
    {
        // Define cutoff frequency and Q factor
        float frequency = 0.2f;
        float q = 1.0f;

        // Create HighPassFilter instance
        HighPassFilter filter = new HighPassFilter(frequency, q);

        // Define input signal
        float[] inputSignal = { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f };

        // Process signal and print result
        foreach (var sample in inputSignal)
        {
            float output = filter.Process(sample);
            Console.WriteLine($"Input: {sample}, Output: {output}");
        }

        // Change filter cutoff frequency and Q factor
        filter.Change(0.3f, 0.8f);

        // Process signal and print result
        foreach (var sample in inputSignal)
        {
            float output = filter.Process(sample);
            Console.WriteLine($"Input: {sample}, Output after change: {output}");
        }
    }
}

Vorcyc.Mathematics.SignalProcessing.Filters.BiQuad.HighShelfFilter class

Vorcyc.Mathematics.SignalProcessing.Filters.BiQuad.HighShelfFilter implements a biquad high-shelf filter.

Properties

1. Frequency

  • public float Frequency { get; protected set; }
    • Gets shelf frequency.

2. Q

  • public float Q { get; protected set; }
    • Gets Q factor.

3. Gain

  • public float Gain { get; protected set; }
    • Gets gain (dB).

Methods

1. Constructor

  • public HighShelfFilter(float frequency, float q = 1, float gain = 1.0f)
    • Constructs HighShelfFilter instance.
    • Parameters:
      • frequency: normalized shelf frequency, range [0..0.5]..
      • q: Q factor; default 1..
      • gain: gain (dB); default 1.0f..

2. SetCoefficients

  • private void SetCoefficients(float frequency, float q, float gain)
    • sets filter coefficients.
    • Parameters:
      • frequency: normalized shelf frequency, range [0..0.5]..
      • q: Q factor..
      • gain: gain (dB)..

3. Change

  • public void Change(float frequency, float q = 1, float gain = 1.0f)
    • changes filter coefficients online (preserves state).
    • Parameters:
      • frequency: normalized shelf frequency, range [0..0.5]..
      • q: Q factor; default 1..
      • gain: gain (dB); default 1.0f..

Code example

The following example uses HighShelfFilter with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Filters.BiQuad;

public class HighShelfFilterExample
{
    public static void Main()
    {
        // Define shelf frequency, Q factor, and gain
        float frequency = 0.2f;
        float q = 1.0f;
        float gain = 3.0f;

        // Create HighShelfFilter instance
        HighShelfFilter filter = new HighShelfFilter(frequency, q, gain);

        // Define input signal
        float[] inputSignal = { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f };

        // Process signal and print result
        foreach (var sample in inputSignal)
        {
            float output = filter.Process(sample);
            Console.WriteLine($"Input: {sample}, Output: {output}");
        }

        // Change filter shelf frequency, Q factor, and gain
        filter.Change(0.3f, 0.8f, 6.0f);

        // Process signal and print result
        foreach (var sample in inputSignal)
        {
            float output = filter.Process(sample);
            Console.WriteLine($"Input: {sample}, Output after change: {output}");
        }
    }
}

Vorcyc.Mathematics.SignalProcessing.Filters.BiQuad.LowPassFilter class

Vorcyc.Mathematics.SignalProcessing.Filters.BiQuad.LowPassFilter implements a biquad low-pass filter.

Properties

1. Frequency

  • public float Frequency { get; protected set; }
    • Getscutoff frequency.

2. Q

  • public float Q { get; protected set; }
    • Gets Q factor.

Methods

1. Constructor

  • public LowPassFilter(float frequency, float q = 1)
    • Constructs LowPassFilter instance.
    • Parameters:
      • frequency: normalized cutoff frequency, range [0..0.5]..
      • q: Q factor; default 1..

2. SetCoefficients

  • private void SetCoefficients(float frequency, float q)
    • sets filter coefficients.
    • Parameters:
      • frequency: normalized cutoff frequency, range [0..0.5]..
      • q: Q factor..

3. Change

  • public void Change(float frequency, float q = 1)
    • changes filter coefficients online (preserves state).
    • Parameters:
      • frequency: normalized cutoff frequency, range [0..0.5]..
      • q: Q factor; default 1..

Code example

The following example uses LowPassFilter with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Filters.BiQuad;

public class LowPassFilterExample
{
    public static void Main()
    {
        // Define cutoff frequency and Q factor
        float frequency = 0.2f;
        float q = 1.0f;

        // Create LowPassFilter instance
        LowPassFilter filter = new LowPassFilter(frequency, q);

        // Define input signal
        float[] inputSignal = { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f };

        // Process signal and print result
        foreach (var sample in inputSignal)
        {
            float output = filter.Process(sample);
            Console.WriteLine($"Input: {sample}, Output: {output}");
        }

        // Change filter cutoff frequency and Q factor
        filter.Change(0.3f, 0.8f);

        // Process signal and print result
        foreach (var sample in inputSignal)
        {
            float output = filter.Process(sample);
            Console.WriteLine($"Input: {sample}, Output after change: {output}");
        }
    }
}

Vorcyc.Mathematics.SignalProcessing.Filters.BiQuad.LowShelfFilter class

Vorcyc.Mathematics.SignalProcessing.Filters.BiQuad.LowShelfFilter implements a biquad low-shelf filter.

Properties

1. Frequency

  • public float Frequency { get; protected set; }
    • Gets shelf frequency.

2. Q

  • public float Q { get; protected set; }
    • Gets Q factor.

3. Gain

  • public float Gain { get; protected set; }
    • Gets gain (dB).

Methods

1. Constructor

  • public LowShelfFilter(float frequency, float q = 1, float gain = 1.0f)
    • Constructs LowShelfFilter instance.
    • Parameters:
      • frequency: normalized shelf frequency, range [0..0.5]..
      • q: Q factor; default 1..
      • gain: gain (dB); default 1.0f..

2. SetCoefficients

  • private void SetCoefficients(float frequency, float q, float gain)
    • sets filter coefficients.
    • Parameters:
      • frequency: normalized shelf frequency, range [0..0.5]..
      • q: Q factor..
      • gain: gain (dB)..

3. Change

  • public void Change(float frequency, float q = 1, float gain = 1.0f)
    • changes filter coefficients online (preserves state).
    • Parameters:
      • frequency: normalized shelf frequency, range [0..0.5]..
      • q: Q factor; default 1..
      • gain: gain (dB); default 1.0f..

Code example

The following example uses LowShelfFilter with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Filters.BiQuad;

public class LowShelfFilterExample
{
    public static void Main()
    {
        // Define shelf frequency, Q factor, and gain
        float frequency = 0.2f;
        float q = 1.0f;
        float gain = 3.0f;

        // Create LowShelfFilter instance
        LowShelfFilter filter = new LowShelfFilter(frequency, q, gain);

        // Define input signal
        float[] inputSignal = { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f };

        // Process signal and print result
        foreach (var sample in inputSignal)
        {
            float output = filter.Process(sample);
            Console.WriteLine($"Input: {sample}, Output: {output}");
        }

        // Change filter shelf frequency, Q factor, and gain
        filter.Change(0.3f, 0.8f, 6.0f);

        // Process signal and print result
        foreach (var sample in inputSignal)
        {
            float output = filter.Process(sample);
            Console.WriteLine($"Input: {sample}, Output after change: {output}");
        }
    }
}

Vorcyc.Mathematics.SignalProcessing.Filters.BiQuad.NotchFilter class

Vorcyc.Mathematics.SignalProcessing.Filters.BiQuad.NotchFilter implements a biquad notch filter.

Properties

1. Frequency

  • public float Frequency { get; protected set; }
    • Getscenter frequency.

2. Q

  • public float Q { get; protected set; }
    • Gets Q factor.

Methods

1. NotchFilter

  • public NotchFilter(float frequency, float q = 1)
    • Constructs NotchFilter instance.
    • Parameters:
      • frequency: normalized center frequency, range [0..0.5]..
      • q: Q factor; default 1..

2. SetCoefficients

  • private void SetCoefficients(float frequency, float q)
    • sets filter coefficients.
    • Parameters:
      • frequency: normalized center frequency, range [0..0.5]..
      • q: Q factor..

3. Change

  • public void Change(float frequency, float q = 1)
    • changes filter coefficients online (preserves state).
    • Parameters:
      • frequency: normalized center frequency, range [0..0.5]..
      • q: Q factor; default 1..

Code example

The following example uses NotchFilter with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Filters.BiQuad;

public class NotchFilterExample
{
    public static void Main()
    {
        // Define center frequency and Q factor
        float frequency = 0.2f;
        float q = 1.0f;

        // Create NotchFilter instance
        NotchFilter filter = new NotchFilter(frequency, q);

        // Define input signal
        float[] inputSignal = { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f };

        // Process signal and print result
        foreach (var sample in inputSignal)
        {
            float output = filter.Process(sample);
            Console.WriteLine($"Input: {sample}, Output: {output}");
        }

        // Change filter center frequency and Q factor
        filter.Change(0.3f, 0.8f);

        // Process signal and print result
        foreach (var sample in inputSignal)
        {
            float output = filter.Process(sample);
            Console.WriteLine($"Input: {sample}, Output after change: {output}");
        }
    }
}

Vorcyc.Mathematics.SignalProcessing.Filters.BiQuad.PeakFilter class

Vorcyc.Mathematics.SignalProcessing.Filters.BiQuad.PeakFilter implements a biquad peak EQ filter.

Properties

1. Frequency

  • public float Frequency { get; protected set; }
    • Getscenter frequency.

2. Q

  • public float Q { get; protected set; }
    • Gets Q factor.

3. Gain

  • public float Gain { get; protected set; }
    • Gets gain (dB).

Methods

1. PeakFilter

  • public PeakFilter(float frequency, float q = 1, float gain = 1.0f)
    • Constructs PeakFilter instance.
    • Parameters:
      • frequency: normalized center frequency, range [0..0.5]..
      • q: Q factor; default 1..
      • gain: gain (dB); default 1.0f..

2. SetCoefficients

  • private void SetCoefficients(float frequency, float q, float gain)
    • sets filter coefficients.
    • Parameters:
      • frequency: normalized center frequency, range [0..0.5]..
      • q: Q factor..
      • gain: gain (dB)..

3. Change

  • public void Change(float frequency, float q = 1, float gain = 1.0f)
    • changes filter coefficients online (preserves state).
    • Parameters:
      • frequency: normalized center frequency, range [0..0.5]..
      • q: Q factor; default 1..
      • gain: gain (dB); default 1.0f..

Code example

The following example uses PeakFilter with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Filters.BiQuad;

public class PeakFilterExample
{
    public static void Main()
    {
        // Define center frequency, Q factor, and gain
        float frequency = 0.2f;
        float q = 1.0f;
        float gain = 3.0f;

        // Create PeakFilter instance
        PeakFilter filter = new PeakFilter(frequency, q, gain);

        // Define input signal
        float[] inputSignal = { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f };

        // Process signal and print result
        foreach (var sample in inputSignal)
        {
            float output = filter.Process(sample);
            Console.WriteLine($"Input: {sample}, Output: {output}");
        }

        // Change filter center frequency, Q factor, and gain
        filter.Change(0.3f, 0.8f, 6.0f);

        // Process signal and print result
        foreach (var sample in inputSignal)
        {
            float output = filter.Process(sample);
            Console.WriteLine($"Input: {sample}, Output after change: {output}");
        }
    }
}

All types below are in namespace: Vorcyc.Mathematics.SignalProcessing.Filters.Butterworth

Vorcyc.Mathematics.SignalProcessing.Filters.Butterworth.BandPassFilter class

Vorcyc.Mathematics.SignalProcessing.Filters.Butterworth.BandPassFilter implements a band-pass Butterworth filter.

Properties

1. FrequencyLow

  • public float FrequencyLow { get; private set; }
    • Gets low cutoff frequency.

2. FrequencyHigh

  • public float FrequencyHigh { get; private set; }
    • Gets high cutoff frequency.

3. Order

  • public int Order { get; }
    • Getsfilterorder.

Methods

1. BandPassFilter

  • public BandPassFilter(float frequencyLow, float frequencyHigh, int order)
    • Constructs BandPassFilter instance.
    • Parameters:
      • frequencyLow: normalized low cutoff frequency, range [0..0.5]..
      • frequencyHigh: normalized high cutoff frequency, range [0..0.5]..
      • order: filterorder.

2. MakeTf

  • private static TransferFunction MakeTf(float frequencyLow, float frequencyHigh, int order)
    • Generates transfer function.
    • Parameters:
      • frequencyLow: normalized low cutoff frequency, range [0..0.5]..
      • frequencyHigh: normalized high cutoff frequency, range [0..0.5]..
      • order: filterorder.
    • Returns: transfer function.

3. Change

  • public void Change(float frequencyLow, float frequencyHigh)
    • changes filter coefficients online (preserves state).
    • Parameters:
      • frequencyLow: normalized low cutoff frequency, range [0..0.5]..
      • frequencyHigh: normalized high cutoff frequency, range [0..0.5]..

Code example

The following example uses BandPassFilter with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Filters.Butterworth;

public class BandPassFilterExample
{
    public static void Main()
    {
        // Define low/high cutoff frequencies and filter order
        float frequencyLow = 0.1f;
        float frequencyHigh = 0.3f;
        int order = 4;

        // Create BandPassFilter instance
        BandPassFilter filter = new BandPassFilter(frequencyLow, frequencyHigh, order);

        // Define input signal
        float[] inputSignal = { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f };

        // Process signal and print result
        foreach (var sample in inputSignal)
        {
            float output = filter.Process(sample);
            Console.WriteLine($"Input: {sample}, Output: {output}");
        }

        // Change filter low and high cutoff frequencies
        filter.Change(0.2f, 0.4f);

        // Process signal and print result
        foreach (var sample in inputSignal)
        {
            float output = filter.Process(sample);
            Console.WriteLine($"Input: {sample}, Output after change: {output}");
        }
    }
}

Vorcyc.Mathematics.SignalProcessing.Filters.Butterworth.BandStopFilter class

Vorcyc.Mathematics.SignalProcessing.Filters.Butterworth.BandStopFilter implements a band-stop Butterworth filter.

Properties

1. FrequencyLow

  • public float FrequencyLow { get; private set; }
    • Gets low cutoff frequency.

2. FrequencyHigh

  • public float FrequencyHigh { get; private set; }
    • Gets high cutoff frequency.

3. Order

  • public int Order { get; }
    • Getsfilterorder.

Methods

1. BandStopFilter

  • public BandStopFilter(float frequencyLow, float frequencyHigh, int order)
    • Constructs BandStopFilter instance.
    • Parameters:
      • frequencyLow: normalized low cutoff frequency, range [0..0.5]..
      • frequencyHigh: normalized high cutoff frequency, range [0..0.5]..
      • order: filterorder.

2. MakeTf

  • private static TransferFunction MakeTf(float frequencyLow, float frequencyHigh, int order)
    • Generates transfer function.
    • Parameters:
      • frequencyLow: normalized low cutoff frequency, range [0..0.5]..
      • frequencyHigh: normalized high cutoff frequency, range [0..0.5]..
      • order: filterorder.
    • Returns: transfer function.

3. Change

  • public void Change(float frequencyLow, float frequencyHigh)
    • changes filter coefficients online (preserves state).
    • Parameters:
      • frequencyLow: normalized low cutoff frequency, range [0..0.5]..
      • frequencyHigh: normalized high cutoff frequency, range [0..0.5]..

Code example

The following example uses BandStopFilter with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Filters.Butterworth;
public class BandStopFilterExample
{
    public static void Main()
    {
        // Define low/high cutoff frequencies and filter order
        float frequencyLow = 0.1f;
        float frequencyHigh = 0.3f;
        int order = 4;

        // Create BandStopFilter instance
        BandStopFilter filter = new BandStopFilter(frequencyLow, frequencyHigh, order);

        // Define input signal
        float[] inputSignal = { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f };

        // Process signal and print result
        foreach (var sample in inputSignal)
        {
            float output = filter.Process(sample);
            Console.WriteLine($"Input: {sample}, Output: {output}");
        }

        // Change filter low and high cutoff frequencies
        filter.Change(0.2f, 0.4f);

        // Process signal and print result
        foreach (var sample in inputSignal)
        {
            float output = filter.Process(sample);
            Console.WriteLine($"Input: {sample}, Output after change: {output}");
        }
    }
}

Vorcyc.Mathematics.SignalProcessing.Filters.Butterworth.HighPassFilter class

Vorcyc.Mathematics.SignalProcessing.Filters.Butterworth.HighPassFilter implements a high-pass Butterworth filter.

Properties

1. Frequency

  • public float Frequency { get; private set; }
    • Getscutoff frequency.

2. Order

  • public int Order { get; }
    • Getsfilterorder.

Methods

1. HighPassFilter

  • public HighPassFilter(float frequency, int order)
    • Constructs HighPassFilter instance.
    • Parameters:
      • frequency: normalized cutoff frequency, range [0..0.5]..
      • order: filterorder.

2. MakeTf

  • private static TransferFunction MakeTf(float frequency, int order)
    • Generates transfer function.
    • Parameters:
      • frequency: normalized cutoff frequency, range [0..0.5]..
      • order: filterorder.
    • Returns: transfer function.

3. Change

  • public void Change(float frequency)
    • changes filter coefficients online (preserves state).
    • Parameters:
      • frequency: normalized cutoff frequency, range [0..0.5]..

Code example

The following example uses HighPassFilter with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Filters.Butterworth;

public class HighPassFilterExample
{
    public static void Main()
    {
        // Define cutoff frequency and filter order
        float frequency = 0.2f;
        int order = 4;

        // Create HighPassFilter instance
        HighPassFilter filter = new HighPassFilter(frequency, order);

        // Define input signal
        float[] inputSignal = { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f };

        // Process signal and print result
        foreach (var sample in inputSignal)
        {
            float output = filter.Process(sample);
            Console.WriteLine($"Input: {sample}, Output: {output}");
        }

        // Change filter cutoff frequency
        filter.Change(0.3f);

        // Process signal and print result
        foreach (var sample in inputSignal)
        {
            float output = filter.Process(sample);
            Console.WriteLine($"Input: {sample}, Output after change: {output}");
        }
    }
}

Vorcyc.Mathematics.SignalProcessing.Filters.Butterworth.LowPassFilter class

Vorcyc.Mathematics.SignalProcessing.Filters.Butterworth.LowPassFilter implements a low-pass Butterworth filter.

Properties

1. Frequency

  • public float Frequency { get; private set; }
    • Getscutoff frequency.

2. Order

  • public int Order { get; }
    • Getsfilterorder.

Methods

1. LowPassFilter

  • public LowPassFilter(float frequency, int order)
    • Constructs LowPassFilter instance.
    • Parameters:
      • frequency: normalized cutoff frequency, range [0..0.5]..
      • order: filterorder.

2. MakeTf

  • private static TransferFunction MakeTf(float frequency, int order)
    • Generates transfer function.
    • Parameters:
      • frequency: normalized cutoff frequency, range [0..0.5]..
      • order: filterorder.
    • Returns: transfer function.

3. Change

  • public void Change(float frequency)
    • changes filter coefficients online (preserves state).
    • Parameters:
      • frequency: normalized cutoff frequency, range [0..0.5]..

Code example

The following example uses LowPassFilter with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Filters.Butterworth;

public class LowPassFilterExample
{
    public static void Main()
    {
        // Define cutoff frequency and filter order
        float frequency = 0.2f;
        int order = 4;

        // Create LowPassFilter instance
        LowPassFilter filter = new LowPassFilter(frequency, order);

        // Define input signal
        float[] inputSignal = { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f };

        // Process signal and print result
        foreach (var sample in inputSignal)
        {
            float output = filter.Process(sample);
            Console.WriteLine($"Input: {sample}, Output: {output}");
        }

        // Change filter cutoff frequency
        filter.Change(0.3f);

        // Process signal and print result
        foreach (var sample in inputSignal)
        {
            float output = filter.Process(sample);
            Console.WriteLine($"Input: {sample}, Output after change: {output}");
        }
    }
}

Vorcyc.Mathematics.SignalProcessing.Filters.Butterworth.PrototypeButterworth class

Vorcyc.Mathematics.SignalProcessing.Filters.Butterworth.PrototypeButterworth generates Butterworthfilterprototype static class.

Methods

1. Poles

  • public static ComplexFp32[] Poles(int order)
    • computes analog poles of Butterworth filter of given order.
    • Parameters:
      • order: filterorder.
    • Returns: ComplexFp32 array of Butterworth filter poles.

Code example

The following example uses PrototypeButterworth.Poles with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Filters.Butterworth;

public class PrototypeButterworthExample
{
    public static void Main()
    {
        // Define filterorder
        int order = 4;

        // Compute Butterworth filter poles
        ComplexFp32[] poles = PrototypeButterworth.Poles(order);

        // Print poles
        foreach (var pole in poles)
        {
            Console.WriteLine($"Pole: {pole.Real} + {pole.Imaginary}i");
        }
    }
}

All types below are in namespace: Vorcyc.Mathematics.SignalProcessing.Filters.ChebyshevI

Vorcyc.Mathematics.SignalProcessing.Filters.ChebyshevI.BandPassFilter class

Vorcyc.Mathematics.SignalProcessing.Filters.ChebyshevI.BandPassFilter implements a band-pass Chebyshev type I filter.

Properties

1. FrequencyLow

  • public float FrequencyLow { get; private set; }
    • Gets low cutoff frequency.

2. FrequencyHigh

  • public float FrequencyHigh { get; private set; }
    • Gets high cutoff frequency.

3. Ripple

  • public float Ripple { get; private set; }
    • Gets ripple (dB).

4. Order

  • public int Order { get; }
    • Getsfilterorder.

Methods

1. BandPassFilter

  • public BandPassFilter(float frequencyLow, float frequencyHigh, int order, float ripple = 0.1f)
    • Constructs BandPassFilter instance.
    • Parameters:
      • frequencyLow: normalized low cutoff frequency, range [0..0.5]..
      • frequencyHigh: normalized high cutoff frequency, range [0..0.5]..
      • order: filterorder.
      • ripple: ripple (dB); default 0.1f..

2. MakeTf

  • private static TransferFunction MakeTf(float frequencyLow, float frequencyHigh, int order, float ripple = 0.1f)
    • Generates transfer function.
    • Parameters:
      • frequencyLow: normalized low cutoff frequency, range [0..0.5]..
      • frequencyHigh: normalized high cutoff frequency, range [0..0.5]..
      • order: filterorder.
      • ripple: ripple (dB); default 0.1f..
    • Returns: transfer function.

3. Change

  • public void Change(float frequencyLow, float frequencyHigh, float ripple = 0.1f)
    • changes filter coefficients online (preserves state).
    • Parameters:
      • frequencyLow: normalized low cutoff frequency, range [0..0.5]..
      • frequencyHigh: normalized high cutoff frequency, range [0..0.5]..
      • ripple: ripple (dB); default 0.1f..

Code example

The following example uses BandPassFilter with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Filters.ChebyshevI;
public class BandPassFilterExample
{
    public static void Main()
    {
        // Define low/high cutoff, order, and ripple
        float frequencyLow = 0.1f;
        float frequencyHigh = 0.3f;
        int order = 4;
        float ripple = 0.1f;

        // Create BandPassFilter instance
        BandPassFilter filter = new BandPassFilter(frequencyLow, frequencyHigh, order, ripple);

        // Define input signal
        float[] inputSignal = { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f };

        // Process signal and print result
        foreach (var sample in inputSignal)
        {
            float output = filter.Process(sample);
            Console.WriteLine($"Input: {sample}, Output: {output}");
        }

        // Change filter low/high cutoff and ripple
        filter.Change(0.2f, 0.4f, 0.2f);

        // Process signal and print result
        foreach (var sample in inputSignal)
        {
            float output = filter.Process(sample);
            Console.WriteLine($"Input: {sample}, Output after change: {output}");
        }
    }
}

Vorcyc.Mathematics.SignalProcessing.Filters.ChebyshevI.BandStopFilter class

Vorcyc.Mathematics.SignalProcessing.Filters.ChebyshevI.BandStopFilter implements a band-stop Chebyshev type I filter.

Properties

1. FrequencyLow

  • public float FrequencyLow { get; private set; }
    • Gets low cutoff frequency.

2. FrequencyHigh

  • public float FrequencyHigh { get; private set; }
    • Gets high cutoff frequency.

3. Ripple

  • public float Ripple { get; private set; }
    • Gets ripple (dB).

4. Order

  • public int Order { get; }
    • Getsfilterorder.

Methods

1. BandStopFilter

  • public BandStopFilter(float frequencyLow, float frequencyHigh, int order, float ripple = 0.1f)
    • Constructs BandStopFilter instance.
    • Parameters:
      • frequencyLow: normalized low cutoff frequency, range [0..0.5]..
      • frequencyHigh: normalized high cutoff frequency, range [0..0.5]..
      • order: filterorder.
      • ripple: ripple (dB); default 0.1f..

2. MakeTf

  • private static TransferFunction MakeTf(float frequencyLow, float frequencyHigh, int order, float ripple = 0.1f)
    • Generates transfer function.
    • Parameters:
      • frequencyLow: normalized low cutoff frequency, range [0..0.5]..
      • frequencyHigh: normalized high cutoff frequency, range [0..0.5]..
      • order: filterorder.
      • ripple: ripple (dB); default 0.1f..
    • Returns: transfer function.

3. Change

  • public void Change(float frequencyLow, float frequencyHigh, float ripple = 0.1f)
    • changes filter coefficients online (preserves state).
    • Parameters:
      • frequencyLow: normalized low cutoff frequency, range [0..0.5]..
      • frequencyHigh: normalized high cutoff frequency, range [0..0.5]..
      • ripple: ripple (dB); default 0.1f..

Code example

The following example uses BandStopFilter with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Filters.ChebyshevI;

public class BandStopFilterExample
{
    public static void Main()
    {
        // Define low/high cutoff, order, and ripple
        float frequencyLow = 0.1f;
        float frequencyHigh = 0.3f;
        int order = 4;
        float ripple = 0.1f;

        // Create BandStopFilter instance
        BandStopFilter filter = new BandStopFilter(frequencyLow, frequencyHigh, order, ripple);

        // Define input signal
        float[] inputSignal = { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f };

        // Process signal and print result
        foreach (var sample in inputSignal)
        {
            float output = filter.Process(sample);
            Console.WriteLine($"Input: {sample}, Output: {output}");
        }

        // Change filter low/high cutoff and ripple
        filter.Change(0.2f, 0.4f, 0.2f);

        // Process signal and print result
        foreach (var sample in inputSignal)
        {
            float output = filter.Process(sample);
            Console.WriteLine($"Input: {sample}, Output after change: {output}");
        }
    }
}

Vorcyc.Mathematics.SignalProcessing.Filters.ChebyshevI.HighPassFilter class

Vorcyc.Mathematics.SignalProcessing.Filters.ChebyshevI.HighPassFilter implements a high-pass Chebyshev type I filter.

Properties

1. Frequency

  • public float Frequency { get; private set; }
    • Getscutoff frequency.

2. Ripple

  • public float Ripple { get; private set; }
    • Gets ripple (dB).

3. Order

  • public int Order { get; }
    • Getsfilterorder.

Methods

1. HighPassFilter

  • public HighPassFilter(float frequency, int order, float ripple = 0.1f)
    • Constructs HighPassFilter instance.
    • Parameters:
      • frequency: normalized cutoff frequency, range [0..0.5]..
      • order: filterorder.
      • ripple: ripple (dB); default 0.1f..

2. MakeTf

  • private static TransferFunction MakeTf(float frequency, int order, float ripple = 0.1f)
    • Generates transfer function.
    • Parameters:
      • frequency: normalized cutoff frequency, range [0..0.5]..
      • order: filterorder.
      • ripple: ripple (dB); default 0.1f..
    • Returns: transfer function.

3. Change

  • public void Change(float frequency, float ripple = 0.1f)
    • changes filter coefficients online (preserves state).
    • Parameters:
      • frequency: normalized cutoff frequency, range [0..0.5]..
      • ripple: ripple (dB); default 0.1f..

Code example

The following example uses HighPassFilter with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Filters.ChebyshevI;
public class HighPassFilterExample
{
    public static void Main()
    {
        // Define cutoff frequency, order, and ripple
        float frequency = 0.2f;
        int order = 4;
        float ripple = 0.1f;

        // Create HighPassFilter instance
        HighPassFilter filter = new HighPassFilter(frequency, order, ripple);

        // Define input signal
        float[] inputSignal = { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f };

        // Process signal and print result
        foreach (var sample in inputSignal)
        {
            float output = filter.Process(sample);
            Console.WriteLine($"Input: {sample}, Output: {output}");
        }

        // Change filter cutoff frequency and ripple
        filter.Change(0.3f, 0.2f);

        // Process signal and print result
        foreach (var sample in inputSignal)
        {
            float output = filter.Process(sample);
            Console.WriteLine($"Input: {sample}, Output after change: {output}");
        }
    }
}

Vorcyc.Mathematics.SignalProcessing.Filters.ChebyshevI.LowPassFilter class

Vorcyc.Mathematics.SignalProcessing.Filters.ChebyshevI.LowPassFilter implements a low-pass Chebyshev type I filter.

Properties

1. Frequency

  • public float Frequency { get; private set; }
    • Getscutoff frequency.

2. Ripple

  • public float Ripple { get; private set; }
    • Gets ripple (dB).

3. Order

  • public int Order { get; }
    • Getsfilterorder.

Methods

1. LowPassFilter

  • public LowPassFilter(float frequency, int order, float ripple = 0.1f)
    • Constructs LowPassFilter instance.
    • Parameters:
      • frequency: normalized cutoff frequency, range [0..0.5]..
      • order: filterorder.
      • ripple: ripple (dB); default 0.1f..

2. MakeTf

  • private static TransferFunction MakeTf(float frequency, int order, float ripple = 0.1f)
    • Generates transfer function.
    • Parameters:
      • frequency: normalized cutoff frequency, range [0..0.5]..
      • order: filterorder.
      • ripple: ripple (dB); default 0.1f..
    • Returns: transfer function.

3. Change

  • public void Change(float frequency, float ripple = 0.1f)
    • changes filter coefficients online (preserves state).
    • Parameters:
      • frequency: normalized cutoff frequency, range [0..0.5]..
      • ripple: ripple (dB); default 0.1f..

Code example

The following example uses LowPassFilter with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Filters.ChebyshevI;

public class LowPassFilterExample
{
    public static void Main()
    {
        // Define cutoff frequency, order, and ripple
        float frequency = 0.2f;
        int order = 4;
        float ripple = 0.1f;

        // Create LowPassFilter instance
        LowPassFilter filter = new LowPassFilter(frequency, order, ripple);

        // Define input signal
        float[] inputSignal = { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f };

        // Process signal and print result
        foreach (var sample in inputSignal)
        {
            float output = filter.Process(sample);
            Console.WriteLine($"Input: {sample}, Output: {output}");
        }

        // Change filter cutoff frequency and ripple
        filter.Change(0.3f, 0.2f);

        // Process signal and print result
        foreach (var sample in inputSignal)
        {
            float output = filter.Process(sample);
            Console.WriteLine($"Input: {sample}, Output after change: {output}");
        }
    }
}

Vorcyc.Mathematics.SignalProcessing.Filters.ChebyshevI.PrototypeChebyshevI class

Vorcyc.Mathematics.SignalProcessing.Filters.ChebyshevI.PrototypeChebyshevI is a static class that generates Chebyshev type I filter prototypes.

Methods

1. Poles

  • public static ComplexFp32[] Poles(int order, float ripple = 0.1f)
    • computes analog poles of Chebyshev type I filter of given order.
    • Parameters:
      • order: filterorder.
      • ripple: ripple (dB); default 0.1f..
    • Returns: ComplexFp32 array of Chebyshev type I filter poles.

Code example

The following example uses PrototypeChebyshevI.Poles with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Filters.ChebyshevI;

public class PrototypeChebyshevIExample
{
    public static void Main()
    {
        // Define filter order and ripple
        int order = 4;
        float ripple = 0.1f;

        // Compute Chebyshev type I filter poles
        ComplexFp32[] poles = PrototypeChebyshevI.Poles(order, ripple);

        // Print poles
        foreach (var pole in poles)
        {
            Console.WriteLine($"Pole: {pole.Real} + {pole.Imaginary}i");
        }
    }
}

All types below are in namespace: Vorcyc.Mathematics.SignalProcessing.Filters.ChebyshevII

Vorcyc.Mathematics.SignalProcessing.Filters.ChebyshevII.BandPassFilter class

Vorcyc.Mathematics.SignalProcessing.Filters.ChebyshevII.BandPassFilter implements a band-pass Chebyshev type II filter. ripple is the stopband attenuation in dB (MATLAB cheby2 Rs; default 20, must be positive); frequencyLow / frequencyHigh are the stopband edges.

Properties

1. FrequencyLow

  • public float FrequencyLow { get; private set; }
    • Gets low cutoff frequency.

2. FrequencyHigh

  • public float FrequencyHigh { get; private set; }
    • Gets high cutoff frequency.

3. Ripple

  • public float Ripple { get; private set; }
    • Gets the stopband attenuation (dB).

4. Order

  • public int Order { get; }
    • Getsfilterorder.

Methods

1. BandPassFilter

  • public BandPassFilter(float frequencyLow, float frequencyHigh, int order, float ripple = 20f)
    • Constructs BandPassFilter instance.
    • Parameters:
      • frequencyLow: normalized low cutoff frequency, range [0..0.5].
      • frequencyHigh: normalized high cutoff frequency, range [0..0.5].
      • order: filterorder.
      • ripple: stopband attenuation (dB), must be positive; default 20f.

2. MakeTf

  • private static TransferFunction MakeTf(float frequencyLow, float frequencyHigh, int order, float ripple = 20f)
    • Generates transfer function.
    • Parameters:
      • frequencyLow: normalized low cutoff frequency, range [0..0.5].
      • frequencyHigh: normalized high cutoff frequency, range [0..0.5].
      • order: filterorder.
      • ripple: stopband attenuation (dB); default 20f.
    • Returns: transfer function.

3. Change

  • public void Change(float frequencyLow, float frequencyHigh, float ripple = 20f)
    • changes filter coefficients online (preserves state).
    • Parameters:
      • frequencyLow: normalized low cutoff frequency, range [0..0.5].
      • frequencyHigh: normalized high cutoff frequency, range [0..0.5].
      • ripple: stopband attenuation (dB); default 20f.

Code example

The following example uses BandPassFilter with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Filters.ChebyshevII;

public class BandPassFilterExample
{
    public static void Main()
    {
        // Define low/high cutoff, order, and ripple (stopband attenuation in dB)
        float frequencyLow = 0.1f;
        float frequencyHigh = 0.3f;
        int order = 4;
        float ripple = 40f;

        // Create BandPassFilter instance
        BandPassFilter filter = new BandPassFilter(frequencyLow, frequencyHigh, order, ripple);

        // Define input signal
        float[] inputSignal = { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f };

        // Process signal and print result
        foreach (var sample in inputSignal)
        {
            float output = filter.Process(sample);
            Console.WriteLine($"Input: {sample}, Output: {output}");
        }

        // Change filter low/high cutoff and ripple
        filter.Change(0.2f, 0.4f, 30f);

        // Process signal and print result
        foreach (var sample in inputSignal)
        {
            float output = filter.Process(sample);
            Console.WriteLine($"Input: {sample}, Output after change: {output}");
        }
    }
}

Vorcyc.Mathematics.SignalProcessing.Filters.ChebyshevII.BandStopFilter class

Vorcyc.Mathematics.SignalProcessing.Filters.ChebyshevII.BandStopFilter implements a band-stop Chebyshev type II filter. ripple is the stopband attenuation in dB (MATLAB cheby2 Rs; default 20, must be positive).

Properties

1. FrequencyLow

  • public float FrequencyLow { get; private set; }
    • Gets low cutoff frequency.

2. FrequencyHigh

  • public float FrequencyHigh { get; private set; }
    • Gets high cutoff frequency.

3. Ripple

  • public float Ripple { get; private set; }
    • Gets the stopband attenuation (dB).

4. Order

  • public int Order { get; }
    • Getsfilterorder.

Methods

1. BandStopFilter

  • public BandStopFilter(float frequencyLow, float frequencyHigh, int order, float ripple = 20f)
    • Constructs BandStopFilter instance.
    • Parameters:
      • frequencyLow: normalized low cutoff frequency, range [0..0.5].
      • frequencyHigh: normalized high cutoff frequency, range [0..0.5].
      • order: filterorder.
      • ripple: stopband attenuation (dB), must be positive; default 20f.

2. MakeTf

  • private static TransferFunction MakeTf(float frequencyLow, float frequencyHigh, int order, float ripple = 20f)
    • Generates transfer function.
    • Parameters:
      • frequencyLow: normalized low cutoff frequency, range [0..0.5].
      • frequencyHigh: normalized high cutoff frequency, range [0..0.5].
      • order: filterorder.
      • ripple: stopband attenuation (dB); default 20f.
    • Returns: transfer function.

3. Change

  • public void Change(float frequencyLow, float frequencyHigh, float ripple = 20f)
    • changes filter coefficients online (preserves state).
    • Parameters:
      • frequencyLow: normalized low cutoff frequency, range [0..0.5].
      • frequencyHigh: normalized high cutoff frequency, range [0..0.5].
      • ripple: stopband attenuation (dB); default 20f.

Code example

The following example uses BandStopFilter with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Filters.ChebyshevII;

public class BandStopFilterExample
{
    public static void Main()
    {
        // Define low/high cutoff, order, and ripple (stopband attenuation in dB)
        float frequencyLow = 0.1f;
        float frequencyHigh = 0.3f;
        int order = 4;
        float ripple = 40f;

        // Create BandStopFilter instance
        BandStopFilter filter = new BandStopFilter(frequencyLow, frequencyHigh, order, ripple);

        // Define input signal
        float[] inputSignal = { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f };

        // Process signal and print result
        foreach (var sample in inputSignal)
        {
            float output = filter.Process(sample);
            Console.WriteLine($"Input: {sample}, Output: {output}");
        }

        // Change filter low/high cutoff and ripple
        filter.Change(0.2f, 0.4f, 30f);

        // Process signal and print result
        foreach (var sample in inputSignal)
        {
            float output = filter.Process(sample);
            Console.WriteLine($"Input: {sample}, Output after change: {output}");
        }
    }
}

Vorcyc.Mathematics.SignalProcessing.Filters.ChebyshevII.HighPassFilter class

Vorcyc.Mathematics.SignalProcessing.Filters.ChebyshevII.HighPassFilter implements a high-pass Chebyshev type II filter. ripple is the stopband attenuation in dB (MATLAB cheby2 Rs; default 20, must be positive); frequency is the stopband edge.

Properties

1. Frequency

  • public float Frequency { get; private set; }
    • Getscutoff frequency.

2. Ripple

  • public float Ripple { get; private set; }
    • Gets the stopband attenuation (dB).

3. Order

  • public int Order { get; }
    • Getsfilterorder.

Methods

1. HighPassFilter

  • public HighPassFilter(float frequency, int order, float ripple = 20f)
    • Constructs HighPassFilter instance.
    • Parameters:
      • frequency: normalized cutoff frequency, range [0..0.5].
      • order: filterorder.
      • ripple: stopband attenuation (dB), must be positive; default 20f.

2. MakeTf

  • private static TransferFunction MakeTf(float frequency, int order, float ripple = 20f)
    • Generates transfer function.
    • Parameters:
      • frequency: normalized cutoff frequency, range [0..0.5].
      • order: filterorder.
      • ripple: stopband attenuation (dB); default 20f.
    • Returns: transfer function.

3. Change

  • public void Change(float frequency, float ripple = 20f)
    • changes filter coefficients online (preserves state).
    • Parameters:
      • frequency: normalized cutoff frequency, range [0..0.5].
      • ripple: stopband attenuation (dB); default 20f.

Code example

The following example uses HighPassFilter with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Filters.ChebyshevII;

public class HighPassFilterExample
{
    public static void Main()
    {
        // Define cutoff frequency, order, and ripple (stopband attenuation in dB)
        float frequency = 0.2f;
        int order = 4;
        float ripple = 40f;

        // Create HighPassFilter instance
        HighPassFilter filter = new HighPassFilter(frequency, order, ripple);

        // Define input signal
        float[] inputSignal = { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f };

        // Process signal and print result
        foreach (var sample in inputSignal)
        {
            float output = filter.Process(sample);
            Console.WriteLine($"Input: {sample}, Output: {output}");
        }

        // Change filter cutoff frequency and ripple
        filter.Change(0.3f, 30f);

        // Process signal and print result
        foreach (var sample in inputSignal)
        {
            float output = filter.Process(sample);
            Console.WriteLine($"Input: {sample}, Output after change: {output}");
        }
    }
}

Vorcyc.Mathematics.SignalProcessing.Filters.ChebyshevII.LowPassFilter class

Vorcyc.Mathematics.SignalProcessing.Filters.ChebyshevII.LowPassFilter implements a low-pass Chebyshev type II filter. ripple is the stopband attenuation in dB (MATLAB cheby2 Rs; default 20, must be positive); frequency is the stopband edge, where the response is exactly -ripple dB (DC gain is 1).

Properties

1. Frequency

  • public float Frequency { get; private set; }
    • Getscutoff frequency.

2. Ripple

  • public float Ripple { get; private set; }
    • Gets the stopband attenuation (dB).

3. Order

  • public int Order { get; }
    • Getsfilterorder.

Methods

1. LowPassFilter

  • public LowPassFilter(float frequency, int order, float ripple = 20f)
    • Constructs LowPassFilter instance.
    • Parameters:
      • frequency: normalized cutoff frequency, range [0..0.5].
      • order: filterorder.
      • ripple: stopband attenuation (dB), must be positive; default 20f.

2. MakeTf

  • private static TransferFunction MakeTf(float frequency, int order, float ripple = 20f)
    • Generates transfer function.
    • Parameters:
      • frequency: normalized cutoff frequency, range [0..0.5].
      • order: filterorder.
      • ripple: stopband attenuation (dB); default 20f.
    • Returns: transfer function.

3. Change

  • public void Change(float frequency, float ripple = 20f)
    • changes filter coefficients online (preserves state).
    • Parameters:
      • frequency: normalized cutoff frequency, range [0..0.5].
      • ripple: stopband attenuation (dB); default 20f.

Code example

The following example uses LowPassFilter with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Filters.ChebyshevII;

public class LowPassFilterExample
{
    public static void Main()
    {
        // Define cutoff frequency, order, and ripple (stopband attenuation in dB)
        float frequency = 0.2f;
        int order = 4;
        float ripple = 40f;

        // Create LowPassFilter instance
        LowPassFilter filter = new LowPassFilter(frequency, order, ripple);

        // Define input signal
        float[] inputSignal = { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f };

        // Process signal and print result
        foreach (var sample in inputSignal)
        {
            float output = filter.Process(sample);
            Console.WriteLine($"Input: {sample}, Output: {output}");
        }

        // Change filter cutoff frequency and ripple
        filter.Change(0.3f, 30f);

        // Process signal and print result
        foreach (var sample in inputSignal)
        {
            float output = filter.Process(sample);
            Console.WriteLine($"Input: {sample}, Output after change: {output}");
        }
    }
}

Vorcyc.Mathematics.SignalProcessing.Filters.ChebyshevII.PrototypeChebyshevII class

Vorcyc.Mathematics.SignalProcessing.Filters.ChebyshevII.PrototypeChebyshevII is a static class that generates Chebyshev type II filter prototypes (MATLAB / SciPy cheb2ap convention: stopband edge at 1 rad/s).

Methods

1. Poles

  • public static ComplexFp32[] Poles(int order, float ripple = 20f)
    • computes analog poles of Chebyshev type II filter of given order.
    • Parameters:
      • order: filterorder.
      • ripple: stopband attenuation (dB), must be positive (ArgumentOutOfRangeException otherwise); default 20f.
    • Returns: ComplexFp32 array of Chebyshev type II filter poles.

2. Zeros

  • public static ComplexFp32[] Zeros(int order)
    • computes analog zeros of Chebyshev type II filter of given order.
    • Parameters:
      • order: filterorder.
    • Returns: ComplexFp32 array of Chebyshev type II filter zeros.

Code example

The following example uses PrototypeChebyshevII.Poles and Zeros with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Filters.ChebyshevII;

public class PrototypeChebyshevIIExample
{
    public static void Main()
    {
        // Define filter order and ripple (stopband attenuation in dB)
        int order = 4;
        float ripple = 40f;

        // Compute Chebyshev type II filter poles
        ComplexFp32[] poles = PrototypeChebyshevII.Poles(order, ripple);

        // Print poles
        foreach (var pole in poles)
        {
            Console.WriteLine($"Pole: {pole.Real} + {pole.Imaginary}i");
        }

        // Compute Chebyshev type II filter zeros
        ComplexFp32[] zeros = PrototypeChebyshevII.Zeros(order);

        // Print zeros
        foreach (var zero in zeros)
        {
            Console.WriteLine($"Zero: {zero.Real} + {zero.Imaginary}i");
        }
    }
}

All types below are in namespace: Vorcyc.Mathematics.SignalProcessing.Filters.Elliptic

Vorcyc.Mathematics.SignalProcessing.Filters.Elliptic.BandPassFilter class

Vorcyc.Mathematics.SignalProcessing.Filters.Elliptic.BandPassFilter implements a band-pass elliptic filter.

Properties

1. FrequencyLow

  • public float FrequencyLow { get; private set; }
    • Gets low cutoff frequency.

2. FrequencyHigh

  • public float FrequencyHigh { get; private set; }
    • Gets high cutoff frequency.

3. RipplePassband

  • public float RipplePassband { get; private set; }
    • Gets passband ripple (dB).

4. RippleStopband

  • public float RippleStopband { get; private set; }
    • Gets stopband ripple (dB).

5. Order

  • public int Order { get; }
    • Getsfilterorder.

Methods

1. BandPassFilter

  • public BandPassFilter(float frequencyLow, float frequencyHigh, int order, float ripplePass = 1f, float rippleStop = 20f)
    • Constructs BandPassFilter instance.
    • Parameters:
      • frequencyLow: normalized low cutoff frequency, range [0..0.5]..
      • frequencyHigh: normalized high cutoff frequency, range [0..0.5]..
      • order: filterorder.
      • ripplePass: passbandripple (dB), default 1f..
      • rippleStop: stopbandripple (dB), default 20f..

2. MakeTf

  • private static TransferFunction MakeTf(float frequencyLow, float frequencyHigh, int order, float ripplePass = 1, float rippleStop = 20)
    • Generates transfer function.
    • Parameters:
      • frequencyLow: normalized low cutoff frequency, range [0..0.5]..
      • frequencyHigh: normalized high cutoff frequency, range [0..0.5]..
      • order: filterorder.
      • ripplePass: passbandripple (dB), default 1f..
      • rippleStop: stopbandripple (dB), default 20f..
    • Returns: transfer function.

3. Change

  • public void Change(float frequencyLow, float frequencyHigh, float ripplePass = 1, float rippleStop = 20f)
    • changes filter coefficients online (preserves state).
    • Parameters:
      • frequencyLow: normalized low cutoff frequency, range [0..0.5]..
      • frequencyHigh: normalized high cutoff frequency, range [0..0.5]..
      • ripplePass: passbandripple (dB), default 1f..
      • rippleStop: stopbandripple (dB), default 20f..

Code example

The following example uses BandPassFilter with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Filters.Elliptic;
public class BandPassFilterExample
{
    public static void Main()
    {
        // Define low/high cutoff, order, passband and stopband ripple
        float frequencyLow = 0.1f;
        float frequencyHigh = 0.3f;
        int order = 4;
        float ripplePass = 1f;
        float rippleStop = 20f;

        // Create BandPassFilter instance
        BandPassFilter filter = new BandPassFilter(frequencyLow, frequencyHigh, order, ripplePass, rippleStop);

        // Define input signal
        float[] inputSignal = { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f };

        // Process signal and print result
        foreach (var sample in inputSignal)
        {
            float output = filter.Process(sample);
            Console.WriteLine($"Input: {sample}, Output: {output}");
        }

        // Change filter low/high cutoff, passband and stopband ripple
        filter.Change(0.2f, 0.4f, 0.5f, 25f);

        // Process signal and print result
        foreach (var sample in inputSignal)
        {
            float output = filter.Process(sample);
            Console.WriteLine($"Input: {sample}, Output after change: {output}");
        }
    }
}

Vorcyc.Mathematics.SignalProcessing.Filters.Elliptic.BandStopFilter class

Vorcyc.Mathematics.SignalProcessing.Filters.Elliptic.BandStopFilter implements a band-stop elliptic filter.

Properties

1. FrequencyLow

  • public float FrequencyLow { get; private set; }
    • Gets low cutoff frequency.

2. FrequencyHigh

  • public float FrequencyHigh { get; private set; }
    • Gets high cutoff frequency.

3. RipplePassband

  • public float RipplePassband { get; private set; }
    • Gets passband ripple (dB).

4. RippleStopband

  • public float RippleStopband { get; private set; }
    • Gets stopband ripple (dB).

5. Order

  • public int Order { get; }
    • Getsfilterorder.

Methods

1. BandStopFilter

  • public BandStopFilter(float frequencyLow, float frequencyHigh, int order, float ripplePass = 1f, float rippleStop = 20f)
    • Constructs BandStopFilter instance.
    • Parameters:
      • frequencyLow: normalized low cutoff frequency, range [0..0.5]..
      • frequencyHigh: normalized high cutoff frequency, range [0..0.5]..
      • order: filterorder.
      • ripplePass: passbandripple (dB), default 1f..
      • rippleStop: stopbandripple (dB), default 20f..

2. MakeTf

  • private static TransferFunction MakeTf(float frequencyLow, float frequencyHigh, int order, float ripplePass = 1f, float rippleStop = 20f)
    • Generates transfer function.
    • Parameters:
      • frequencyLow: normalized low cutoff frequency, range [0..0.5]..
      • frequencyHigh: normalized high cutoff frequency, range [0..0.5]..
      • order: filterorder.
      • ripplePass: passbandripple (dB), default 1f..
      • rippleStop: stopbandripple (dB), default 20f..
    • Returns: transfer function.

3. Change

  • public void Change(float frequencyLow, float frequencyHigh, float ripplePass = 1f, float rippleStop = 20f)
    • changes filter coefficients online (preserves state).
    • Parameters:
      • frequencyLow: normalized low cutoff frequency, range [0..0.5]..
      • frequencyHigh: normalized high cutoff frequency, range [0..0.5]..
      • ripplePass: passbandripple (dB), default 1f..
      • rippleStop: stopbandripple (dB), default 20f..

Code example

The following example uses BandStopFilter with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Filters.Elliptic;

public class BandStopFilterExample
{
    public static void Main()
    {
        // Define low/high cutoff, order, passband and stopband ripple
        float frequencyLow = 0.1f;
        float frequencyHigh = 0.3f;
        int order = 4;
        float ripplePass = 1f;
        float rippleStop = 20f;

        // Create BandStopFilter instance
        BandStopFilter filter = new BandStopFilter(frequencyLow, frequencyHigh, order, ripplePass, rippleStop);

        // Define input signal
        float[] inputSignal = { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f };

        // Process signal and print result
        foreach (var sample in inputSignal)
        {
            float output = filter.Process(sample);
            Console.WriteLine($"Input: {sample}, Output: {output}");
        }

        // Change filter low/high cutoff, passband and stopband ripple
        filter.Change(0.2f, 0.4f, 0.5f, 25f);

        // Process signal and print result
        foreach (var sample in inputSignal)
        {
            float output = filter.Process(sample);
            Console.WriteLine($"Input: {sample}, Output after change: {output}");
        }
    }
}

Vorcyc.Mathematics.SignalProcessing.Filters.Elliptic.HighPassFilter class

Vorcyc.Mathematics.SignalProcessing.Filters.Elliptic.HighPassFilter implements a high-pass elliptic filter.

Properties

1. Frequency

  • public float Frequency { get; private set; }
    • Getscutoff frequency.

2. RipplePassband

  • public float RipplePassband { get; private set; }
    • Gets passband ripple (dB).

3. RippleStopband

  • public float RippleStopband { get; private set; }
    • Gets stopband ripple (dB).

4. Order

  • public int Order { get; }
    • Getsfilterorder.

Methods

1. HighPassFilter

  • public HighPassFilter(float frequency, int order, float ripplePass = 1f, float rippleStop = 20f)
    • Constructs HighPassFilter instance.
    • Parameters:
      • frequency: normalized cutoff frequency, range [0..0.5]..
      • order: filterorder.
      • ripplePass: passbandripple (dB), default 1f..
      • rippleStop: stopbandripple (dB), default 20f..

2. MakeTf

  • private static TransferFunction MakeTf(float frequency, int order, float ripplePass = 1f, float rippleStop = 20f)
    • Generates transfer function.
    • Parameters:
      • frequency: normalized cutoff frequency, range [0..0.5]..
      • order: filterorder.
      • ripplePass: passbandripple (dB), default 1f..
      • rippleStop: stopbandripple (dB), default 20f..
    • Returns: transfer function.

3. Change

  • public void Change(float frequency, float ripplePass = 1f, float rippleStop = 20f)
    • changes filter coefficients online (preserves state).
    • Parameters:
      • frequency: normalized cutoff frequency, range [0..0.5]..
      • ripplePass: passbandripple (dB), default 1f..
      • rippleStop: stopbandripple (dB), default 20f..

Code example

The following example uses HighPassFilter with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Filters.Elliptic;

public class HighPassFilterExample
{
    public static void Main()
    {
        // Define cutoff frequency, order, passband and stopband ripple
        float frequency = 0.2f;
        int order = 4;
        float ripplePass = 1f;
        float rippleStop = 20f;

        // Create HighPassFilter instance
        HighPassFilter filter = new HighPassFilter(frequency, order, ripplePass, rippleStop);

        // Define input signal
        float[] inputSignal = { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f };

        // Process signal and print result
        foreach (var sample in inputSignal)
        {
            float output = filter.Process(sample);
            Console.WriteLine($"Input: {sample}, Output: {output}");
        }

        // Change filter cutoff, passband and stopband ripple
        filter.Change(0.3f, 0.5f, 25f);

        // Process signal and print result
        foreach (var sample in inputSignal)
        {
            float output = filter.Process(sample);
            Console.WriteLine($"Input: {sample}, Output after change: {output}");
        }
    }
}

Vorcyc.Mathematics.SignalProcessing.Filters.Elliptic.LowPassFilter class

Vorcyc.Mathematics.SignalProcessing.Filters.Elliptic.LowPassFilter implements a low-pass elliptic filter.

Properties

1. Frequency

  • public float Frequency { get; private set; }
    • Getscutoff frequency.

2. RipplePassband

  • public float RipplePassband { get; private set; }
    • Gets passband ripple (dB).

3. RippleStopband

  • public float RippleStopband { get; private set; }
    • Gets stopband ripple (dB).

4. Order

  • public int Order { get; }
    • Getsfilterorder.

Methods

1. LowPassFilter

  • public LowPassFilter(float frequency, int order, float ripplePass = 1, float rippleStop = 20f)
    • Constructs LowPassFilter instance.
    • Parameters:
      • frequency: normalized cutoff frequency, range [0..0.5]..
      • order: filterorder.
      • ripplePass: passbandripple (dB), default 1f..
      • rippleStop: stopbandripple (dB), default 20f..

2. MakeTf

  • private static TransferFunction MakeTf(float frequency, int order, float ripplePass = 1, float rippleStop = 20f)
    • Generates transfer function.
    • Parameters:
      • frequency: normalized cutoff frequency, range [0..0.5]..
      • order: filterorder.
      • ripplePass: passbandripple (dB), default 1f..
      • rippleStop: stopbandripple (dB), default 20f..
    • Returns: transfer function.

3. Change

  • public void Change(float frequency, float ripplePass = 1, float rippleStop = 20f)
    • changes filter coefficients online (preserves state).
    • Parameters:
      • frequency: normalized cutoff frequency, range [0..0.5]..
      • ripplePass: passbandripple (dB), default 1f..
      • rippleStop: stopbandripple (dB), default 20f..

Code example

The following example uses LowPassFilter with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Filters.Elliptic;
public class LowPassFilterExample
{
    public static void Main()
    {
        // Define cutoff frequency, order, passband and stopband ripple
        float frequency = 0.2f;
        int order = 4;
        float ripplePass = 1f;
        float rippleStop = 20f;

        // Create LowPassFilter instance
        LowPassFilter filter = new LowPassFilter(frequency, order, ripplePass, rippleStop);

        // Define input signal
        float[] inputSignal = { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f };

        // Process signal and print result
        foreach (var sample in inputSignal)
        {
            float output = filter.Process(sample);
            Console.WriteLine($"Input: {sample}, Output: {output}");
        }

        // Change filter cutoff, passband and stopband ripple
        filter.Change(0.3f, 0.5f, 25f);

        // Process signal and print result
        foreach (var sample in inputSignal)
        {
            float output = filter.Process(sample);
            Console.WriteLine($"Input: {sample}, Output after change: {output}");
        }
    }
}

Vorcyc.Mathematics.SignalProcessing.Filters.Elliptic.PrototypeElliptic class

Vorcyc.Mathematics.SignalProcessing.Filters.Elliptic.PrototypeElliptic generates ellipticfilterprototype static class.

Methods

1. Poles

  • public static ComplexFp32[] Poles(int order, float ripplePass = 1f, float rippleStop = 20f)
    • Computes analog poles of elliptic filter of given order.
    • Parameters:
      • order: filterorder.
      • ripplePass: passbandripple (dB), default 1f..
      • rippleStop: stopbandripple (dB), default 20f..
    • Returns: ComplexFp32 array of elliptic filter poles.

2. Zeros

  • public static ComplexFp32[] Zeros(int order, float ripplePass = 1, float rippleStop = 20)
    • Computes analog zeros of elliptic filter of given order.
    • Parameters:
      • order: filterorder.
      • ripplePass: passbandripple (dB), default 1f..
      • rippleStop: stopbandripple (dB), default 20f..
    • Returns: ComplexFp32 array of elliptic filter zeros.

3. Landen

  • public static float[] Landen(float k, int iterCount = 12)
    • Computes Landen sequence.
    • Parameters:
      • k: parameters K.
      • iterCount: Iteration count; default 12 (5 left up to ~1e-6 relative error for large Rs/Rp ratios or high orders).
    • Returns: float array of Landen sequence.

4. Cde

  • public static ComplexFp32 Cde(ComplexFp32 x, float[] landen)
    • Computes Cde.
    • Parameters:
      • x: parameters X.
      • landen: Landen sequence.
    • Returns: ComplexFp32 value of computation result.

5. Sne

  • public static ComplexFp32 Sne(ComplexFp32 x, float[] landen)
    • Computes Sne.
    • Parameters:
      • x: parameters X.
      • landen: Landen sequence.
    • Returns: ComplexFp32 value of computation result.

6. Asne

  • public static ComplexFp32 Asne(ComplexFp32 x, float k, int iterCount = 12)
    • Computes inverse Sne.
    • Parameters:
      • x: parameters X.
      • k: parameters K.
      • iterCount: Iteration count; default 12.
    • Returns: ComplexFp32 value of computation result.

Code example

The following example uses PrototypeElliptic.Poles and Zeros with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Filters.Elliptic;

public class PrototypeEllipticExample
{
    public static void Main()
    {
        // Define filter order, passband and stopband ripple
        int order = 4;
        float ripplePass = 1f;
        float rippleStop = 20f;

        // Compute elliptic filter poles
        ComplexFp32[] poles = PrototypeElliptic.Poles(order, ripplePass, rippleStop);

        // Print poles
        foreach (var pole in poles)
        {
            Console.WriteLine($"Pole: {pole.Real} + {pole.Imaginary}i");
        }

        // Compute elliptic filter zeros
        ComplexFp32[] zeros = PrototypeElliptic.Zeros(order, ripplePass, rippleStop);

        // Print zeros
        foreach (var zero in zeros)
        {
            Console.WriteLine($"Zero: {zero.Real} + {zero.Imaginary}i");
        }
    }
}

All types below are in namespace: Vorcyc.Mathematics.SignalProcessing.Filters.Fda

Vorcyc.Mathematics.SignalProcessing.Filters.Fda.DesignFilter class

Vorcyc.Mathematics.SignalProcessing.Filters.Fda.DesignFilter is a static class for filter design and analysis.

Methods

1. FirWinFdLp

  • public static float[] FirWinFdLp(int order, float frequency, float delay, WindowType window = WindowType.Blackman)
    • Designs ideal low-pass fractional-delay FIR filter using sinc-window method.
    • Parameters:
      • order: filterorder.
      • frequency: normalized cutoff frequency, range [0..0.5]..
      • delay: Fractional delay.
      • window: window, default WindowType.Blackman.
    • Returns: filter coefficient array.

2. FirWinFdHp

  • public static float[] FirWinFdHp(int order, float frequency, float delay, WindowType window = WindowType.Blackman)
    • Designs ideal high-pass fractional-delay FIR filter using sinc-window method.
    • Parameters:
      • order: filterorder.
      • frequency: normalized cutoff frequency, range [0..0.5]..
      • delay: Fractional delay.
      • window: window, default WindowType.Blackman.
    • Returns: filter coefficient array.

3. FirWinFdBp

  • public static float[] FirWinFdBp(int order, float frequencyLow, float frequencyHigh, float delay, WindowType window = WindowType.Blackman)
    • Designs ideal band-pass fractional-delay FIR filter using sinc-window method.
    • Parameters:
      • order: filterorder.
      • frequencyLow: normalized low cutoff frequency, range [0..0.5]..
      • frequencyHigh: normalized high cutoff frequency, range [0..0.5]..
      • delay: Fractional delay.
      • window: window, default WindowType.Blackman.
    • Returns: filter coefficient array.

4. FirWinFdBs

  • public static float[] FirWinFdBs(int order, float frequencyLow, float frequencyHigh, float delay, WindowType window = WindowType.Blackman)
    • Designs ideal band-stop fractional-delay FIR filter using sinc-window method.
    • Parameters:
      • order: filterorder.
      • frequencyLow: normalized low cutoff frequency, range [0..0.5]..
      • frequencyHigh: normalized high cutoff frequency, range [0..0.5]..
      • delay: Fractional delay.
      • window: window, default WindowType.Blackman.
    • Returns: filter coefficient array.

5. FirWinFdAp

  • public static float[] FirWinFdAp(int order, float delay, WindowType window = WindowType.Blackman)
    • Designs ideal all-pass fractional-delay FIR filter using sinc-window method.
    • Parameters:
      • order: filterorder.
      • delay: Fractional delay.
      • window: window, default WindowType.Blackman.
    • Returns: filter coefficient array.

6. NormalizeKernel

  • public static void NormalizeKernel(float[] kernel, float frequency = 0)
    • Normalizes frequency response at given frequency (maps kernel coefficients to [0, 1]).
    • Parameters:
      • kernel: Kernel coefficient array.
      • frequency: frequency, default 0.

Code example

The following example uses DesignFilter.FirWinFdLp with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Filters.Fda;

public class DesignFilterExample
{
    public static void Main()
    {
        // Define filter order, cutoff frequency, and fractional delay
        int order = 64;
        float frequency = 0.25f;
        float delay = 0.5f;

        // Design low-pass fractional-delay FIR filter
        float[] filterCoefficients = DesignFilter.FirWinFdLp(order, frequency, delay);

        // Print filter coefficients
        foreach (var coeff in filterCoefficients)
        {
            Console.WriteLine($"Coefficient: {coeff}");
        }
    }
}

Vorcyc.Mathematics.SignalProcessing.Filters.Fda.FilterBanks class

Vorcyc.Mathematics.SignalProcessing.Filters.Fda.FilterBanks is a static class for filter-bank design.

Methods

1. Triangular

  • public static float[][] Triangular(int fftSize, int samplingRate, (float, float, float)[] frequencies, VtlnWarper? vtln = null, Func<float, float>? mapper = null)
    • Generates triangular filter-bank weights from given frequencies.
    • Parameters:
      • fftSize: Assumed FFT size.
      • samplingRate: Assumed signal sample rate.
      • frequencies: Array of frequency tuples per filter (left, center, right).
      • vtln: VTLN frequency warper; default null.
      • mapper: Frequency scale mapper (e.g. herz-to-mel) for weighting only; default null.
    • Returns: filter-bank weight array.

2. Rectangular

  • public static float[][] Rectangular(int fftSize, int samplingRate, (float, float, float)[] frequencies, VtlnWarper? vtln = null, Func<float, float>? mapper = null)
    • Generates rectangular filter-bank weights from given frequencies.
    • Parameters:
      • fftSize: Assumed FFT size.
      • samplingRate: Assumed signal sample rate.
      • frequencies: Array of frequency tuples per filter (left, center, right).
      • vtln: VTLN frequency warper; default null.
      • mapper: Frequency scale mapper (e.g. herz-to-mel); default null.
    • Returns: filter-bank weight array.

3. Trapezoidal

  • public static float[][] Trapezoidal(int fftSize, int samplingRate, (float, float, float)[] frequencies, VtlnWarper? vtln = null, Func<float, float>? mapper = null)
    • Generates FIR band-pass (near-trapezoidal) filter bank from given frequencies.
    • Parameters:
      • fftSize: Assumed FFT size.
      • samplingRate: Assumed signal sample rate.
      • frequencies: Array of frequency tuples per filter (left, center, right).
      • vtln: VTLN frequency warper; default null.
      • mapper: Frequency scale mapper (e.g. herz-to-mel); default null.
    • Returns: filter-bank weight array.

4. BiQuad

  • public static float[][] BiQuad(int fftSize, int samplingRate, (float, float, float)[] frequencies)
    • Generates overlapping BiQuad band-pass filters from given frequencies.
    • Parameters:
      • fftSize: Assumed FFT size.
      • samplingRate: Assumed signal sample rate.
      • frequencies: Array of frequency tuples per filter (left, center, right).
    • Returns: filter-bank weight array.

5. HerzBands

  • public static (float, float, float)[] HerzBands(int combFilterCount, int samplingRate, float lowFreq = 0, float highFreq = 0f, bool overlap = false)
    • Returns frequency tuples for uniformly spaced bands on the Herz scale.
    • Parameters:
      • combFilterCount: Number of filters.
      • samplingRate: Assumed signal sample rate.
      • lowFreq: Lower frequency bound; default 0.
      • highFreq: Upper frequency bound; default 0.
      • overlap: Whether bands should overlap; default false.
    • Returns: array of frequency tuples.

6. MelBands

  • public static (float, float, float)[] MelBands(int melFilterCount, int samplingRate, float lowFreq = 0f, float highFreq = 0f, bool overlap = true)
    • Returns frequency tuples for uniformly spaced bands on the Mel scale.
    • Parameters:
      • melFilterCount: Number of Mel filters.
      • samplingRate: Assumed signal sample rate.
      • lowFreq: Lower frequency bound; default 0.
      • highFreq: Upper frequency bound; default 0.
      • overlap: Whether bands should overlap; default true.
    • Returns: array of frequency tuples.

7. MelBandsSlaney

  • public static (float, float, float)[] MelBandsSlaney(int melFilterCount, int samplingRate, float lowFreq = 0, float highFreq = 0, bool overlap = true)
    • Returns Mel-scale band frequency tuples (M. Slaney formula).
    • Parameters:
      • melFilterCount: Number of Mel filters.
      • samplingRate: Assumed signal sample rate.
      • lowFreq: Lower frequency bound; default 0.
      • highFreq: Upper frequency bound; default 0.
      • overlap: Whether bands should overlap; default true.
    • Returns: array of frequency tuples.

8. BarkBands

  • public static (float, float, float)[] BarkBands(int barkFilterCount, int samplingRate, float lowFreq = 0f, float highFreq = 0f, bool overlap = true)
    • Returns Bark-scale band frequency tuples (Traunmueller, 1990).
    • Parameters:
      • barkFilterCount: Number of Bark filters.
      • samplingRate: Assumed signal sample rate.
      • lowFreq: Lower frequency bound; default 0.
      • highFreq: Upper frequency bound; default 0.
      • overlap: Whether bands should overlap; default true.
    • Returns: array of frequency tuples.

9. BarkBandsSlaney

  • public static (float, float, float)[] BarkBandsSlaney(int barkFilterCount, int samplingRate, float lowFreq = 0, float highFreq = 0f, bool overlap = true)
    • Returns Bark-scale band frequency tuples (Wang, 1992).
    • Parameters:
      • barkFilterCount: Number of Bark filters.
      • samplingRate: Assumed signal sample rate.
      • lowFreq: Lower frequency bound; default 0.
      • highFreq: Upper frequency bound; default 0.
      • overlap: Whether bands should overlap; default true.
    • Returns: array of frequency tuples.

10. CriticalBands

  • public static (float, float, float)[] CriticalBands(int filterCount, int samplingRate, float lowFreq = 0f, float highFreq = 0f)
    • Returns critical-band frequency tuples.
    • Parameters:
      • filterCount: Number of filters.
      • samplingRate: Assumed signal sample rate.
      • lowFreq: Lower frequency bound; default 0.
      • highFreq: Upper frequency bound; default 0.
    • Returns: array of frequency tuples.

11. OctaveBands

  • public static (float, float, float)[] OctaveBands(int octaveCount, int samplingRate, float lowFreq = 0f, float highFreq = 0f, bool overlap = false)
    • Returns octave-band frequency tuples.
    • Parameters:
      • octaveCount: Number of octave filters.
      • samplingRate: Assumed signal sample rate.
      • lowFreq: Lower frequency bound; default 0.
      • highFreq: Upper frequency bound; default 0.
      • overlap: Whether bands should overlap; default false.
    • Returns: array of frequency tuples.

12. Chroma

  • public static float[][] Chroma(int fftSize, int samplingRate, int chromaCount = 12, float tuning = 0, float centerOctave = 5.0f, float octaveWidth = 2, int norm = 2, bool baseC = true)
    • Generates chroma feature filter bank.
    • Parameters:
      • fftSize: Assumed FFT size.
      • samplingRate: Assumed sample rate.
      • chromaCount: Number of chroma features; default 12.
      • tuning: Detuning from A440 as fraction of chroma bin; default 0.
      • centerOctave: Ignored if octaveWidth=0; otherwise Gaussian window center; default 5.0f.
      • octaveWidth: Rectangular if 0; otherwise Gaussian window width; default 2.
      • norm: Normalization: 0=none, 1=L1, 2=L2; default 2.
      • baseC: If true, filter bank starts at 'C'; else at 'A'; default true.
    • Returns: filter-bank weight array.

13. MelBankSlaney

  • public static float[][] MelBankSlaney(int filterCount, int fftSize, int samplingRate, float lowFreq = 0f, float highFreq = 0f, bool normalizeGain = true, VtlnWarper? vtln = null)
    • Creates overlapping triangular Mel filters (as suggested by Malcolm Slaney).
    • Parameters:
      • filterCount: Number of Mel filters.
      • fftSize: Assumed FFT size.
      • samplingRate: Assumed sample rate.
      • lowFreq: Lower frequency bound; default 0.
      • highFreq: Upper frequency bound; default 0.
      • normalizeGain: True to normalize gain; false for unit height 1.0; default true.
      • vtln: VTLN frequency warper; default null.
    • Returns: filter-bank weight array.

14. BarkBankSlaney

  • public static float[][] BarkBankSlaney(int filterCount, int fftSize, int samplingRate, float lowFreq = 0, float highFreq = 0, float width = 1)
    • Creates overlapping trapezoidal Bark filters (as suggested by Malcolm Slaney).
    • Parameters:
      • filterCount: Number of Bark filters.
      • fftSize: Assumed FFT size.
      • samplingRate: Assumed sample rate.
      • lowFreq: Lower frequency bound; default 0.
      • highFreq: Upper frequency bound; default 0.
      • width: Constant band width; default 1.
    • Returns: filter-bank weight array.

15. Erb

  • public static float[][] Erb(int erbFilterCount, int fftSize, int samplingRate, float lowFreq = 0, float highFreq = 0, bool normalizeGain = true)
    • Creates overlapping ERB filters.
    • Parameters:
      • erbFilterCount: Number of ERB filters.
      • fftSize: Assumed FFT size.
      • samplingRate: Assumed sample rate.
      • lowFreq: Lower frequency bound; default 0.
      • highFreq: Upper frequency bound; default 0.
      • normalizeGain: True to normalize gain; false for unit height 1.0; default true.
    • Returns: filter-bank weight array.

16. Normalize

  • public static void Normalize(int filterCount, (float, float, float)[] frequencies, float[][] filterBank)
    • Normalizes weights (roughly equal energy per band).
    • Parameters:
      • filterCount: Number of filters.
      • frequencies: Array of frequency tuples per filter (left, center, right).
      • filterBank: Filter bank.

17. Apply

  • public static void Apply(float[][] filterbank, float[] spectrum, float[] filtered)
    • Applies filter bank to spectrum and fills filtered spectrum.
    • Parameters:
      • filterbank: Filter bank.
      • spectrum: Spectrum.
      • filtered: Filtered signal spectrum.

18. Apply

  • public static float[][] Apply(float[][] filterbank, IList<float[]> spectrogram)
    • Applies filter bank to all spectra in given sequence.
    • Parameters:
      • filterbank: Filter bank.
      • spectrogram: Output spectra of filtered signal.
    • Returns: array of filtered spectra.

19. ApplyAndLog

  • public static void ApplyAndLog(float[][] filterbank, float[] spectrum, float[] filtered, float floor = float.Epsilon)
    • Applies filter bank to spectrum, then Ln() on result.
    • Parameters:
      • filterbank: Filter bank.
      • spectrum: Spectrum.
      • filtered: Filtered signal spectrum.
      • floor: Log threshold; default float.Epsilon.

20. ApplyAndLog10

  • public static void ApplyAndLog10(float[][] filterbank, float[] spectrum, float[] filtered, float floor = float.Epsilon)
    • Applies filter bank to spectrum, then Log10() on result.
    • Parameters:
      • filterbank: Filter bank.
      • spectrum: Spectrum.
      • filtered: Filtered signal spectrum.
      • floor: Log threshold; default float.Epsilon.

21. ApplyAndToDecibel

  • public static void ApplyAndToDecibel(float[][] filterbank, float[] spectrum, float[] filtered, float minLevel = 1e-10f)
    • Applies filter bank to spectrum, then 10*Log10() (for MFCC comparison with librosa).
    • Parameters:
      • filterbank: Filter bank.
      • spectrum: Spectrum.
      • filtered: Filtered signal spectrum.
      • minLevel: Log threshold; default 1e-10f.

22. ApplyAndPow

  • public static void ApplyAndPow(float[][] filterbank, float[] spectrum, float[] filtered, float power = 1.0f / 3)
    • Applies filter bank to spectrum, then Pow(x, power); e.g. PLP uses power=1/3 (cube root).
    • Parameters:
      • filterbank: Filter bank.
      • spectrum: Spectrum.
      • filtered: Filtered signal spectrum.
      • power: Power; default 1.0f / 3.

Code example

The following example uses FilterBanks.Triangular with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Filters.Fda;

public class FilterBanksExample
{
    public static void Main()
    {
        // Define FFT size, sample rate, and frequency tuples
        int fftSize = 512;
        int samplingRate = 16000;
        (float, float, float)[] frequencies = { (100, 200, 300), (200, 300, 400), (300, 400, 500) };

        // Generate triangular filter-bank weights
        float[][] filterBank = FilterBanks.Triangular(fftSize, samplingRate, frequencies);

        // Print filter-bank weights
        for (int i = 0; i < filterBank.Length; i++)
        {
            Console.WriteLine($"Filter {i + 1}:");
            foreach (var weight in filterBank[i])
            {
                Console.WriteLine(weight);
            }
        }
    }
}

Vorcyc.Mathematics.SignalProcessing.Filters.Fda.Remez class

Vorcyc.Mathematics.SignalProcessing.Filters.Fda.Remez is an equiripple filter designer based on the Remez (Parks–McClellan) algorithm.

Properties

1. Order

  • public int Order { get; private set; }
    • Getsfilterorder.

2. Iterations

  • public int Iterations { get; private set; }
    • Gets actual iteration count.

3. K

  • public int K { get; private set; }
    • Gets number of extremal frequencies (K = Order/2 + 2).

4. InterpolatedResponse

  • public float[] InterpolatedResponse { get; private set; }
    • Gets interpolated frequency response.

5. Error

  • public float[] Error { get; private set; }
    • Gets error array.

6. ExtremalFrequencies

  • public float[] ExtremalFrequencies
    • Gets extremal frequency array.

Methods

1. Remez

  • public Remez(int order, float[] frequencies, float[] desired, float[] weights, int gridDensity = 16)
    • Constructs Remez filter designer.
    • Parameters:
      • order: filterorder.
      • frequencies: Normalized frequency array.
      • desired: Desired response values at given frequencies.
      • weights: Weight array at given frequencies.
      • gridDensity: Grid density; default 16.

2. Design

  • public float[] Design(int maxIterations = 100)
    • Designs optimal equiripple filter and returns kernel.
    • Parameters:
      • maxIterations: Maximum iterations; default 100.
    • Returns: filter coefficient array.

3. DbToPassbandWeight

  • public static float DbToPassbandWeight(float ripple)
    • Converts ripple (dB) to passband weight.
    • Parameters:
      • ripple: Ripple (dB).
    • Returns: passband weight.

4. DbToStopbandWeight

  • public static float DbToStopbandWeight(float ripple)
    • Converts ripple (dB) to stopband weight.
    • Parameters:
      • ripple: Ripple (dB).
    • Returns: stopband weight.

5. EstimateOrder

  • public static int EstimateOrder(float fp, float fa, float dp, float da)
    • Estimates low-pass filter order.
    • Parameters:
      • fp: Passband edge frequency.
      • fa: Stopband edge frequency.
      • dp: Passband weight.
      • da: Stopband weight.
    • Returns: filterorder.

6. EstimateOrder

  • public static int EstimateOrder(float[] frequencies, float[] deltas)
    • Estimates filter order for custom bands.
    • Parameters:
      • frequencies: Edge frequency array.
      • deltas: Weight array.
    • Returns: filterorder.

Code example

The following example uses Remez.Design with comments:

using System;
using System.Text.RegularExpressions;
using Vorcyc.Mathematics.SignalProcessing.Filters.Fda;

public class RemezExample
{
    public static void Main()
    {
        // Define filter order, frequencies, desired response, and weights
        int order = 57;
        float[] frequencies = { 0, 0.15f, 0.17f, 0.5f };
        float[] desired = { 1, 0 };
        float[] weights = { 0.01f, 0.1f };

        // Create Remez instance
        var remez = new Remez(order, frequencies, desired, weights);

        // Design filter and get coefficients
        float[] kernel = remez.Design();

        // Print filter coefficients
        foreach (var coeff in kernel)
        {
            Console.WriteLine($"Coefficient: {coeff}");
        }

        // Print other properties
        Console.WriteLine($"Iterations: {remez.Iterations}");
        Console.WriteLine($"Extremal Frequencies: {string.Join(", ", remez.ExtremalFrequencies)}");
        Console.WriteLine($"Interpolated Response: {string.Join(", ", remez.InterpolatedResponse)}");
        Console.WriteLine($"Error: {string.Join(", ", remez.Error)}");
    }
}

Vorcyc.Mathematics.SignalProcessing.Filters.Fda.VtlnWarper class

Vorcyc.Mathematics.SignalProcessing.Filters.Fda.VtlnWarper implements vocal-tract length normalization (VTLN) similar to Kaldi.

Properties

1. _lowFreq

  • private readonly float _lowFreq
    • Low frequency.

2. _highFreq

  • private readonly float _highFreq
    • High frequency.

3. _lowVtln

  • private readonly float _lowVtln
    • VTLN low frequency.

4. _highVtln

  • private readonly float _highVtln
    • VTLN high frequency.

5. _scale

  • private readonly float _scale
    • Computed intermediate parameters.

6. _scaleLeft

  • private readonly float _scaleLeft
    • Computed intermediate parameters.

7. _scaleRight

  • private readonly float _scaleRight
    • Computed intermediate parameters.

Methods

1. VtlnWarper

  • public VtlnWarper(float alpha, float lowFrequency, float highFrequency, float lowVtln, float highVtln)
    • Constructs VtlnWarper instance.
    • Parameters:
      • alpha: Warp factor.
      • lowFrequency: Low frequency.
      • highFrequency: High frequency.
      • lowVtln: VTLN low frequency.
      • highVtln: VTLN high frequency.

2. Warp

  • public float Warp(float frequency)
    • Warps given frequency.
    • Parameters:
      • frequency: Frequency to warp.
    • Returns: warped frequency.

Code example

The following example uses VtlnWarper.Warp with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Filters.Fda;

public class VtlnWarperExample
{
    public static void Main()
    {
        // Define warp factor and frequency range
        float alpha = 1.2f;
        float lowFrequency = 100f;
        float highFrequency = 8000f;
        float lowVtln = 200f;
        float highVtln = 6000f;

        // Create VtlnWarper instance
        var vtlnWarper = new VtlnWarper(alpha, lowFrequency, highFrequency, lowVtln, highVtln);

        // Warp frequency and print result
        float[] frequencies = { 150f, 300f, 500f, 1000f, 4000f, 7000f };
        foreach (var freq in frequencies)
        {
            float warpedFreq = vtlnWarper.Warp(freq);
            Console.WriteLine($"Original Frequency: {freq}, Warped Frequency: {warpedFreq}");
        }
    }
}

All types below are in namespace: Vorcyc.Mathematics.SignalProcessing.Filters.OnePole

Vorcyc.Mathematics.SignalProcessing.Filters.OnePole.HighPassFilter class

Vorcyc.Mathematics.SignalProcessing.Filters.OnePole.HighPassFilter implements a single-pole high-pass filter.

Properties

1. Frequency

  • public float Frequency { get; protected set; }
    • Getscutoff frequency.

Methods

1. HighPassFilter

  • public HighPassFilter(float frequency)
    • Constructs HighPassFilter instance.
    • Parameters:
      • frequency: cutoff frequency.

2. Change

  • public void Change(float frequency)
    • changes filter coefficients (preserves filter state).
    • Parameters:
      • frequency: cutoff frequency.

Private methods

1. SetCoefficients

  • private void SetCoefficients(float frequency)
    • Sets filter coefficients for given cutoff frequency.
    • Parameters:
      • frequency: cutoff frequency.

Code example

The following example uses HighPassFilter.Change with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Filters.OnePole;

public class HighPassFilterExample
{
    public static void Main()
    {
        // Define cutoff frequency
        float frequency = 0.1f;

        // Create HighPassFilter instance
        var highPassFilter = new HighPassFilter(frequency);

        // Change cutoff frequency
        highPassFilter.Change(0.2f);

        // Print current cutoff frequency
        Console.WriteLine($"Current Cutoff Frequency: {highPassFilter.Frequency}");
    }
}

Vorcyc.Mathematics.SignalProcessing.Filters.OnePole.LowPassFilter class

Vorcyc.Mathematics.SignalProcessing.Filters.OnePole.LowPassFilter implements a single-pole low-pass filter.

Properties

1. Frequency

  • public float Frequency { get; protected set; }
    • Getscutoff frequency.

Methods

1. LowPassFilter

  • public LowPassFilter(float frequency)
    • Constructs LowPassFilter instance.
    • Parameters:
      • frequency: cutoff frequency.

2. Change

  • public void Change(float frequency)
    • changes filter coefficients (preserves filter state).
    • Parameters:
      • frequency: cutoff frequency.

Private methods

1. SetCoefficients

  • private void SetCoefficients(float frequency)
    • Sets filter coefficients for given cutoff frequency.
    • Parameters:
      • frequency: cutoff frequency.

Code example

The following example uses LowPassFilter.Change with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Filters.OnePole;

public class LowPassFilterExample
{
    public static void Main()
    {
        // Define cutoff frequency
        float frequency = 0.1f;

        // Create LowPassFilter instance
        var lowPassFilter = new LowPassFilter(frequency);

        // Change cutoff frequency
        lowPassFilter.Change(0.2f);

        // Print current cutoff frequency
        Console.WriteLine($"Current Cutoff Frequency: {lowPassFilter.Frequency}");
    }
}

Vorcyc.Mathematics.SignalProcessing.Filters.OnePole.OnePoleFilter class

Vorcyc.Mathematics.SignalProcessing.Filters.OnePole.OnePoleFilter is a single-pole IIR filter class.

Methods

1. OnePoleFilter constructor

  • protected OnePoleFilter()
    • Constructs OnePoleFilter with default coefficients.

2. OnePoleFilter constructor

  • public OnePoleFilter(float b, float a)
    • Constructs OnePoleFilter with specified coefficients.
    • Parameters:
      • b: Numerator coefficients.
      • a: poles.

3. Process

  • public override float Process(float sample)
    • Processes one sample.
    • Parameters:
      • sample: input sample.
    • Returns: processed sample.

4. Reset

  • public override void Reset()
    • Resetsfilter.

Example

The following example builds and processes samples with OnePoleFilter with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Filters.OnePole;

public class OnePoleFilterExample
{
    public static void Main()
    {
        // Create OnePoleFilter instance
        var filter = new OnePoleFilter(0.5f, 0.3f);

        // Define input signal
        float[] samples = { 0.5f, 0.6f, 0.55f, 0.7f, 0.65f };

        // Process sample
        Console.WriteLine("Processed Samples:");
        foreach (var sample in samples)
        {
            var processedSample = filter.Process(sample);
            Console.WriteLine(processedSample);
        }

        // Reset filter
        filter.Reset();
    }
}

All types below are in namespace: Vorcyc.Mathematics.SignalProcessing.Filters.Polyphase

Vorcyc.Mathematics.SignalProcessing.Filters.Polyphase.PolyphaseSystem class

Vorcyc.Mathematics.SignalProcessing.Filters.Polyphase.PolyphaseSystem is a polyphase filter system.

Properties

1. Filters

  • public FirFilter[] Filters { get; private set; }
    • Gets polyphase filter with transfer function E(z^k).

2. MultirateFilters

  • public FirFilter[] MultirateFilters { get; private set; }
    • Gets polyphase filter with transfer function E(z) for multirate processing.

Methods

1. PolyphaseSystem constructor

  • public PolyphaseSystem(float[] kernel, int n, int type = 1)
    • Constructs PolyphaseSystem with specified kernel and polyphase count.
    • Parameters:
      • kernel: Filter kernel.
      • n: Number of polyphase filters.
      • type: Polyphase system type (1 or 2).

2. Decimate

  • public DiscreteSignal Decimate(DiscreteSignal signal)
    • Polyphase decimates input signal (type I system).
    • Parameters:
      • signal: input signal.
    • Returns: decimated signal.

3. Interpolate

  • public DiscreteSignal Interpolate(DiscreteSignal signal)
    • Polyphase interpolates input signal (type II system).
    • Parameters:
      • signal: input signal.
    • Returns: interpolated signal.

4. Process

  • public float Process(float sample)
    • Processes one sample.
    • Parameters:
      • sample: input sample.
    • Returns: processed sample.

5. Reset

  • public void Reset()
    • Resets polyphasefilter.

6. ApplyTo

  • public DiscreteSignal ApplyTo(DiscreteSignal signal, FilteringMethod method = FilteringMethod.Auto)
    • Processes entire signal and returns new filtered signal.
    • Parameters:
      • signal: input signal.
      • method: filtering method; default FilteringMethod.Auto..
    • Returns: processed DiscreteSignal.

Example

The following example builds and processes samples with PolyphaseSystem with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Filters.Polyphase;

public class PolyphaseSystemExample
{
    public static void Main()
    {
        // Define filter kernel
        float[] kernel = { 1, 2, 3, 4, 3, 2, 1 };

        // Create PolyphaseSystem instance
        var polyphaseSystem = new PolyphaseSystem(kernel, 3);

        // Define input signal
        float[] samples = { 0.5f, 0.6f, 0.55f, 0.7f, 0.65f };
        var signal = new DiscreteSignal(44100, samples);

        // Perform polyphase decimation
        var decimatedSignal = polyphaseSystem.Decimate(signal);

        // Print decimated signal samples
        Console.WriteLine("Decimated Signal:");
        foreach (var sample in decimatedSignal.Samples)
        {
            Console.WriteLine(sample);
        }

        // Perform polyphase interpolation
        var interpolatedSignal = polyphaseSystem.Interpolate(signal);

        // Print interpolated signal samples
        Console.WriteLine("Interpolated Signal:");
        foreach (var sample in interpolatedSignal.Samples)
        {
            Console.WriteLine(sample);
        }

        // Resetspolyphasefilter
        polyphaseSystem.Reset();
    }
}

Vorcyc.Mathematics.SignalProcessing.Filters.CombFeedbackFilter class

Vorcyc.Mathematics.SignalProcessing.Filters.CombFeedbackFilter implements a feedback comb filter.

Properties

No public properties.

Methods

1. CombFeedbackFilter constructor

  • public CombFeedbackFilter(int m, float b0 = 1.0f, float am = 0.6f)
    • Constructs CombFeedbackFilter instance.
    • Parameters:
      • m: delay.
      • b0: Coefficient b0; default 1.0f.
      • am: Coefficient am; default 0.6f.

2. Process

  • public override float Process(float sample)
    • Processes one sample.
    • Parameters:
      • sample: input sample.
    • Returns: processed sample.

3. ApplyTo

  • public override DiscreteSignal ApplyTo(DiscreteSignal signal, FilteringMethod method = FilteringMethod.Auto)
    • Applies filter to entire signal and returns new filtered signal.
    • Parameters:
      • signal: input signal.
      • method: filtering method; default FilteringMethod.Auto..
    • Returns: processed DiscreteSignal.

4. Change

  • public void Change(float b0, float am)
    • changes filter coefficients (preserves filter state).
    • Parameters:
      • b0: Coefficient b0.
      • am: Coefficient am.

Code example

The following example uses CombFeedbackFilter with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Filters;

public class CombFeedbackFilterExample
{
    public static void Main()
    {
        // Create CombFeedbackFilter instance
        var combFilter = new CombFeedbackFilter(4, 1.0f, 0.6f);

        // Define input signal
        float[] inputSignal = { 0.5f, 0.6f, 0.55f, 0.7f, 0.65f };
        var signal = new DiscreteSignal(44100, inputSignal);

        // Process signal and print result
        foreach (var sample in signal.Samples)
        {
            var processedSample = combFilter.Process(sample);
            Console.WriteLine($"Processed Sample: {processedSample}");
        }

        // Change filter coefficients
        combFilter.Change(0.8f, 0.4f);

        // Process signal and print result
        foreach (var sample in signal.Samples)
        {
            var processedSample = combFilter.Process(sample);
            Console.WriteLine($"Processed Sample after change: {processedSample}");
        }
    }
}

Vorcyc.Mathematics.SignalProcessing.Filters.CombFeedforwardFilter class

Vorcyc.Mathematics.SignalProcessing.Filters.CombFeedforwardFilter implements a feedforward comb filter.

Properties

No public properties.

Methods

1. CombFeedforwardFilter constructor

  • public CombFeedforwardFilter(int m, float b0 = 1f, float bm = 0.5f, bool normalize = true)
    • Constructs CombFeedforwardFilter instance.
    • Parameters:
      • m: delay.
      • b0: Coefficient b0; default 1f.
      • bm: Coefficient bm; default 0.5f.
      • normalize: Whether to normalize frequency response; default true.

2. Process

  • public override float Process(float sample)
    • Processes one sample.
    • Parameters:
      • sample: input sample.
    • Returns: processed sample.

3. ApplyTo

  • public override DiscreteSignal ApplyTo(DiscreteSignal signal, FilteringMethod method = FilteringMethod.Auto)
    • Applies filter to entire signal and returns new filtered signal.
    • Parameters:
      • signal: input signal.
      • method: filtering method; default FilteringMethod.Auto..
    • Returns: processed DiscreteSignal.

4. Change

  • public void Change(float b0, float bm)
    • changes filter coefficients (preserves filter state).
    • Parameters:
      • b0: Coefficient b0.
      • bm: Coefficient bm.

Code example

The following example uses CombFeedforwardFilter with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Filters;

public class CombFeedforwardFilterExample
{
    public static void Main()
    {
        // Create CombFeedforwardFilter instance
        var combFilter = new CombFeedforwardFilter(4, 1f, 0.5f);

        // Define input signal
        float[] inputSignal = { 0.5f, 0.6f, 0.55f, 0.7f, 0.65f };
        var signal = new DiscreteSignal(44100, inputSignal);

        // Process signal and print result
        foreach (var sample in signal.Samples)
        {
            var processedSample = combFilter.Process(sample);
            Console.WriteLine($"Processed Sample: {processedSample}");
        }

        // Change filter coefficients
        combFilter.Change(0.8f, 0.4f);

        // Process signal and print result
        foreach (var sample in signal.Samples)
        {
            var processedSample = combFilter.Process(sample);
            Console.WriteLine($"Processed Sample after change: {processedSample}");
        }
    }
}

Vorcyc.Mathematics.SignalProcessing.Filters.DcRemovalFilter class

Vorcyc.Mathematics.SignalProcessing.Filters.DcRemovalFilter is an IIR filter for DC offset removal.

Properties

No public properties.

Methods

1. DcRemovalFilter constructor

  • public DcRemovalFilter(float r = 0.995f)
    • Constructs DcRemovalFilter instance.
    • Parameters:
      • r: R coefficient, typically in [0.9, 1]; default 0.995f.

2. Process

  • public override float Process(float sample)
    • Processes one sample.
    • Parameters:
      • sample: input sample.
    • Returns: processed sample.

3. Reset

  • public override void Reset()
    • Resetsfilter.

Code example

The following example uses DcRemovalFilter with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Filters;

public class DcRemovalFilterExample
{
    public static void Main()
    {
        // Create DcRemovalFilter instance
        var dcRemovalFilter = new DcRemovalFilter(0.995f);

        // Define input signal
        float[] inputSignal = { 0.5f, 0.6f, 0.55f, 0.7f, 0.65f };

        // Process signal and print result
        foreach (var sample in inputSignal)
        {
            var processedSample = dcRemovalFilter.Process(sample);
            Console.WriteLine($"Processed Sample: {processedSample}");
        }

        // Reset filter
        dcRemovalFilter.Reset();
    }
}

Vorcyc.Mathematics.SignalProcessing.Filters.DeEmphasisFilter class

Vorcyc.Mathematics.SignalProcessing.Filters.DeEmphasisFilter is an IIR de-emphasis filter.

Properties

No public properties.

Methods

1. DeEmphasisFilter constructor

  • public DeEmphasisFilter(float a = 0.97f, bool normalize = false)
    • Constructs DeEmphasisFilter instance.
    • Parameters:
      • a: De-emphasis coefficient; default 0.97f.
      • normalize: Whether to normalize frequency response; default false.

Code example

The following example uses DeEmphasisFilter constructor with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Filters;

public class DeEmphasisFilterExample
{
    public static void Main()
    { 
        // Create DeEmphasisFilter instance
        var deEmphasisFilter = new DeEmphasisFilter(0.97f, true);

        // Define input signal
        float[] inputSignal = { 0.5f, 0.6f, 0.55f, 0.7f, 0.65f };

        // Process signal and print result
        foreach (var sample in inputSignal)
        {
            var processedSample = deEmphasisFilter.Process(sample);
            Console.WriteLine($"Processed Sample: {processedSample}");
        }

        // Reset filter
        deEmphasisFilter.Reset();
    }
}

Vorcyc.Mathematics.SignalProcessing.Filters.HilbertFilter class

Vorcyc.Mathematics.SignalProcessing.Filters.HilbertFilter is a class that implements Hilbert filter.

Properties

1. Size

  • public int Size { get; }
    • Gets filter size.

Methods

1. HilbertFilter constructor

  • public HilbertFilter(int size = 128)
    • Constructs HilbertFilter instance.
    • Parameters:
      • size: Filter size; default 128.

2. MakeKernel

  • private static IEnumerable<float> MakeKernel(int size)
    • Generates filter kernel of given size.
    • Parameters:
      • size: Kernel size.
    • Returns: float array of filter kernel.

Code example

The following example uses HilbertFilter constructor with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Filters;

public class HilbertFilterExample
{
    public static void Main()
    {
        // Create HilbertFilter instance
        var hilbertFilter = new HilbertFilter(128);

        // Define input signal
        float[] inputSignal = { 0.5f, 0.6f, 0.55f, 0.7f, 0.65f };

        // Process signal and print result
        foreach (var sample in inputSignal)
        {
            var processedSample = hilbertFilter.Process(sample);
            Console.WriteLine($"Processed Sample: {processedSample}");
        }
    }
}

Vorcyc.Mathematics.SignalProcessing.Filters.MedianFilter class

Vorcyc.Mathematics.SignalProcessing.Filters.MedianFilter implements median filtering.

Properties

1. Size

  • public int Size { get; }
    • Gets median filter size.

Methods

1. MedianFilter constructor

  • public MedianFilter(int size = 9)
    • Constructs MedianFilter instance.
    • Parameters:
      • size: Filter size; default 9.

2. ApplyTo

  • public DiscreteSignal ApplyTo(DiscreteSignal signal, FilteringMethod method = FilteringMethod.Auto)
    • Applies filter to entire signal and returns new filtered signal.
    • Parameters:
      • signal: input signal.
      • method: filtering method; default FilteringMethod.Auto..
    • Returns: processed DiscreteSignal.

3. Process

  • public float Process(float sample)
    • Processes one sample.
    • Parameters:
      • sample: input sample.
    • Returns: processed sample.

4. Reset

  • public void Reset()
    • Resetsfilter.

Code example

The following example uses MedianFilter with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Filters;

public class MedianFilterExample
{
    public static void Main()
    {
        // Create MedianFilter instance
        var medianFilter = new MedianFilter(9);

        // Define input signal
        float[] inputSignal = { 0.5f, 0.6f, 0.55f, 0.7f, 0.65f };

        // Process signal and print result
        foreach (var sample in inputSignal)
        {
            var processedSample = medianFilter.Process(sample);
            Console.WriteLine($"Processed Sample: {processedSample}");
        }

        // Reset filter
        medianFilter.Reset();
    }
}

Vorcyc.Mathematics.SignalProcessing.Filters.MedianFilter2 class

Vorcyc.Mathematics.SignalProcessing.Filters.MedianFilter2 implements median filtering; faster than MedianFilter but only for small sizes (up to about 5).

Properties

1. Size

  • public int Size { get; }
    • Gets median filter size.

Methods

1. MedianFilter2 constructor

  • public MedianFilter2(int size = 9)
    • Constructs MedianFilter2 instance.
    • Parameters:
      • size: Filter size; default 9.

2. ApplyTo

  • public DiscreteSignal ApplyTo(DiscreteSignal signal, FilteringMethod method = FilteringMethod.Auto)
    • Applies filter to entire signal and returns new filtered signal.
    • Parameters:
      • signal: input signal.
      • method: filtering method; default FilteringMethod.Auto..
    • Returns: processed DiscreteSignal.

3. Process

  • public float Process(float sample)
    • Processes one sample.
    • Parameters:
      • sample: input sample.
    • Returns: processed sample.

4. Reset

  • public void Reset()
    • Resetsfilter.

Code example

The following example uses MedianFilter2 with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Filters;

public class MedianFilter2Example
{
    public static void Main()
    {
        // Create MedianFilter2 instance
        var medianFilter2 = new MedianFilter2(9);

        // Define input signal
        float[] inputSignal = { 0.5f, 0.6f, 0.55f, 0.7f, 0.65f };

        // Process signal and print result
        foreach (var sample in inputSignal)
        {
            var processedSample = medianFilter2.Process(sample);
            Console.WriteLine($"Processed Sample: {processedSample}");
        }

        // Reset filter
        medianFilter2.Reset();
    }
}

Vorcyc.Mathematics.SignalProcessing.Filters.MovingAverageFilter class

Vorcyc.Mathematics.SignalProcessing.Filters.MovingAverageFilter implements a non-recursive moving average filter.

Properties

1. Size

  • public int Size { get; }
    • Gets filter size.

Methods

1. MovingAverageFilter constructor

  • public MovingAverageFilter(int size = 9)
    • Constructs MovingAverageFilter instance.
    • Parameters:
      • size: Filter size; default 9.

2. MakeKernel

  • private static IEnumerable<float> MakeKernel(int size)
    • Generates filter kernel of given size.
    • Parameters:
      • size: Kernel size.
    • Returns: float array of filter kernel.

Code example

The following example uses MovingAverageFilter constructor with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Filters;

public class MovingAverageFilterExample
{
    public static void Main()
    {
        // Create MovingAverageFilter instance
        var movingAverageFilter = new MovingAverageFilter(9);

        // Define input signal
        float[] inputSignal = { 0.5f, 0.6f, 0.55f, 0.7f, 0.65f };

        // Process signal and print result
        foreach (var sample in inputSignal)
        {
            var processedSample = movingAverageFilter.Process(sample);
            Console.WriteLine($"Processed Sample: {processedSample}");
        }
    }
}

Vorcyc.Mathematics.SignalProcessing.Filters.MovingAverageRecursiveFilter class

Vorcyc.Mathematics.SignalProcessing.Filters.MovingAverageRecursiveFilter implements a fast recursive moving average filter.

Properties

1. Size

  • public int Size { get; }
    • Gets filter size.

Methods

1. MovingAverageRecursiveFilter constructor

  • public MovingAverageRecursiveFilter(int size = 9)
    • Constructs MovingAverageRecursiveFilter instance.
    • Parameters:
      • size: Filter size; default 9.

2. MakeNumerator

  • private static float[] MakeNumerator(int size)
    • Generates filter numerator of given size.
    • Parameters:
      • size: Numerator size.
    • Returns: float array of filter numerator.

3. ApplyTo

  • public override DiscreteSignal ApplyTo(DiscreteSignal signal, FilteringMethod method = FilteringMethod.Auto)
    • Applies filter to entire signal and returns new filtered signal.
    • Parameters:
      • signal: input signal.
      • method: filtering method; default FilteringMethod.Auto..
    • Returns: processed DiscreteSignal.

4. Process

  • public override float Process(float sample)
    • Processes one sample.
    • Parameters:
      • sample: input sample.
    • Returns: processed sample.

5. Reset

  • public override void Reset()
    • Resetsfilter.

Code example

The following example uses MovingAverageRecursiveFilter with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Filters;

public class MovingAverageRecursiveFilterExample
{
    public static void Main()
    {
        // Create MovingAverageRecursiveFilter instance
        var movingAverageRecursiveFilter = new MovingAverageRecursiveFilter(9);

        // Define input signal
        float[] inputSignal = { 0.5f, 0.6f, 0.55f, 0.7f, 0.65f };
        var signal = new DiscreteSignal(44100, inputSignal);

        // Process signal and print result
        foreach (var sample in signal.Samples)
        {
            var processedSample = movingAverageRecursiveFilter.Process(sample);
            Console.WriteLine($"Processed Sample: {processedSample}");
        }

        // Reset filter
        movingAverageRecursiveFilter.Reset();
    }
}

Vorcyc.Mathematics.SignalProcessing.Filters.PreEmphasisFilter class

Vorcyc.Mathematics.SignalProcessing.Filters.PreEmphasisFilter implements pre-emphasis FIR filtering.

Properties

No public properties.

Methods

1. PreEmphasisFilter constructor

  • public PreEmphasisFilter(float a = 0.97f, bool normalize = false)
    • Constructs PreEmphasisFilter instance.
    • Parameters:
      • a: Pre-emphasis coefficient; default 0.97f.
      • normalize: Whether to normalize frequency response; default false.

2. Process

  • public override float Process(float sample)
    • Processes one sample.
    • Parameters:
      • sample: input sample.
    • Returns: processed sample.

3. ApplyTo

  • public override DiscreteSignal ApplyTo(DiscreteSignal signal, FilteringMethod method = FilteringMethod.Auto)
    • Applies filter to entire signal and returns new filtered signal.
    • Parameters:
      • signal: input signal.
      • method: filtering method; default FilteringMethod.Auto..
    • Returns: processed DiscreteSignal.

4. Reset

  • public override void Reset()
    • Resetsfilter.

Code example

The following example uses PreEmphasisFilter with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Filters;

public class PreEmphasisFilterExample
{
    public static void Main()
    {
        // Create PreEmphasisFilter instance
        var preEmphasisFilter = new PreEmphasisFilter(0.97f, true);

        // Define input signal
        float[] inputSignal = { 0.5f, 0.6f, 0.55f, 0.7f, 0.65f };
        var signal = new DiscreteSignal(44100, inputSignal);

        // Process signal and print result
        foreach (var sample in signal.Samples)
        {
            var processedSample = preEmphasisFilter.Process(sample);
            Console.WriteLine($"Processed Sample: {processedSample}");
        }

        // Reset filter
        preEmphasisFilter.Reset();
    }
}

Vorcyc.Mathematics.SignalProcessing.Filters.RastaFilter class

Vorcyc.Mathematics.SignalProcessing.Filters.RastaFilter is an IIR RASTA filter for robust speech processing.

Properties

No public properties.

Methods

1. RastaFilter constructor

  • public RastaFilter(float pole = 0.98f)
    • Constructs RastaFilter instance.
    • Parameters:
      • pole: poles, default 0.98f.

Code example

The following example uses RastaFilter constructor with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Filters;

public class RastaFilterExample
{
    public static void Main()
    {
        // Create RastaFilter instance
        var rastaFilter = new RastaFilter(0.98f);

        // Define input signal
        float[] inputSignal = { 0.5f, 0.6f, 0.55f, 0.7f, 0.65f };

        // Process signal and print result
        foreach (var sample in inputSignal)
        {
            var processedSample = rastaFilter.Process(sample);
            Console.WriteLine($"Processed Sample: {processedSample}");
        }
    }
}

Vorcyc.Mathematics.SignalProcessing.Filters.SavitzkyGolayFilter class

Vorcyc.Mathematics.SignalProcessing.Filters.SavitzkyGolayFilter is an FIR Savitzky–Golay filter.

Properties

1. Size

  • public int Size { get; }
    • Gets filter size.

Methods

1. SavitzkyGolayFilter constructor

  • public SavitzkyGolayFilter(int size, int deriv = 0)
    • Constructs SavitzkyGolayFilter instance.
    • Parameters:
      • size: Filter size (odd, in range [5..31]).
      • deriv: Derivative (0, 1, or 2); default 0.

Code example

The following example uses SavitzkyGolayFilter constructor with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Filters;

public class SavitzkyGolayFilterExample
{
    public static void Main()
    {
        // Create SavitzkyGolayFilter instance
        var sgFilter = new SavitzkyGolayFilter(11, 0);

        // Define input signal
        float[] inputSignal = { 0.5f, 0.6f, 0.55f, 0.7f, 0.65f };

        // Process signal and print result
        foreach (var sample in inputSignal)
        {
            var processedSample = sgFilter.Process(sample);
            Console.WriteLine($"Processed Sample: {processedSample}");
        }
    }
}

Vorcyc.Mathematics.SignalProcessing.Filters.ThiranFilter class

Vorcyc.Mathematics.SignalProcessing.Filters.ThiranFilter is an IIR N-th order Thiran all-pass interpolation filter.

Properties

No public properties.

Methods

1. ThiranFilter constructor

  • public ThiranFilter(int order, float delta)
    • Constructs ThiranFilter instance.
    • Parameters:
      • order: filterorder.
      • delta: Fractional delay.

2. MakeTf

  • private static TransferFunction MakeTf(int order, float delta)
    • Generates transfer function.
    • Parameters:
      • order: filterorder.
      • delta: Fractional delay.
    • Returns: generated TransferFunction.

3. ThiranCoefficient

  • private static float ThiranCoefficient(int k, int n, float delta)
    • Computes k-th coefficient of transfer function denominator.
    • Parameters:
      • k: Coefficient index.
      • n: filterorder.
      • delta: Fractional delay.
    • Returns: computed coefficient.

Code example

The following example uses ThiranFilter constructor with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Filters;

public class ThiranFilterExample
{
    public static void Main()
    {
        // Define filter order and fractional delay
        int order = 13; float delta = 13.4f;

        // Create ThiranFilter instance
        var thiranFilter = new ThiranFilter(order, delta);

        // Define input signal
        float[] inputSignal = { 0.5f, 0.6f, 0.55f, 0.7f, 0.65f };

        // Process signal and print result
        foreach (var sample in inputSignal)
        {
            var processedSample = thiranFilter.Process(sample);
            Console.WriteLine($"Processed Sample: {processedSample}");
        }
    }
}

Vorcyc.Mathematics.SignalProcessing.Filters.WienerFilter class

Vorcyc.Mathematics.SignalProcessing.Filters.WienerFilter implements a Wiener filter; same as scipy.signal.wiener().

Properties

No public properties.

Methods

1. WienerFilter constructor

  • public WienerFilter(int size = 3, float noise = 0.0f)
    • Constructs WienerFilter instance.
    • Parameters:
      • size: Wiener filter size; default 3.
      • noise: Estimated noise power; default 0.0f.

2. ApplyTo

  • public DiscreteSignal ApplyTo(DiscreteSignal signal, FilteringMethod method = FilteringMethod.Auto)
    • Applies filter to entire signal and returns new filtered signal.
    • Parameters:
      • signal: input signal.
      • method: filtering method; default FilteringMethod.Auto..
    • Returns: processed DiscreteSignal.

3. Process

  • public float Process(float sample)
    • Processes one sample.
    • Parameters:
      • sample: input sample.
    • Returns: processed sample.

4. Reset

  • public void Reset()
    • Resetsfilter.

Code example

The following example uses WienerFilter with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Filters;

public class WienerFilterExample
{
    public static void Main()
    {
        // Create WienerFilter instance
        var wienerFilter = new WienerFilter(3, 0.0f);

        // Define input signal
        float[] inputSignal = { 0.5f, 0.6f, 0.55f, 0.7f, 0.65f };
        var signal = new DiscreteSignal(44100, inputSignal);

        // Process signal and print result
        foreach (var sample in signal.Samples)
        {
            var processedSample = wienerFilter.Process(sample);
            Console.WriteLine($"Processed Sample: {processedSample}");
        }

        // Reset filter
        wienerFilter.Reset();
    }
}

Kalman filters

The Vorcyc.Mathematics.SignalProcessing.Filters.Kalman namespace provides generic state-estimation filters. All types are generic over T (a floating-point type).

Type Description
StandardKalmanFilter1D<T> 1D standard Kalman filter; recursive state estimate combining a linear model and measurements (predict + update).
StandardKalmanFilter2D<T> 2D (matrix) standard Kalman filter for two-state linear systems.
ExtendedKalmanFilter1D<T> 1D extended Kalman filter for nonlinear systems; linearizes model/measurement via user-supplied functions.
ExtendedKalmanFilter2D<T> 2D (matrix) extended Kalman filter for nonlinear systems.
UnscentedKalmanFilter1D<T> 1D unscented Kalman filter; handles nonlinearity via the unscented transform (no explicit linearization).
SquareRootKalmanFilter1D<T> 1D square-root Kalman filter; propagates the square root of the covariance for improved numerical stability.
InformationFilter1D<T> 1D information filter; represents uncertainty with the information matrix (inverse covariance).
ParticleFilter1D<T> 1D particle filter; represents the posterior with a weighted particle cloud and importance resampling (nonlinear/non-Gaussian).

Language / 语言: English · 简体中文

Home

首页

Clone this wiki locally