Module_SignalProcessing_Transforms - vorcyc/Vorcyc.Mathematics GitHub Wiki

Location: Home / Signal processing / Transforms

Signal Processing Module

Transforms

The Vorcyc.Mathematics.SignalProcessing.Transforms namespace contains Dct1, Dct2, Dct3, Dct4, FastDct2, FastDct3, FastDct4, FastMdct, and Mdct for discrete cosine transform (DCT) types I–IV and modified DCT (MDCT), including FFT-based fast implementations. Each class provides direct, normalized, inverse, and normalized inverse transforms.

0.10.1: The real-input FFT types RealFft / RealFft64 and the short-time Fourier transform Stft have moved from this namespace to Vorcyc.Mathematics.SignalProcessing.Fourier; see Fourier transforms. This page documents the DCT / MDCT family and mode decomposition.

0.10.7: Mode decomposition lives under Vorcyc.Mathematics.SignalProcessing.Transforms.ModeDecomposition (see Mode decomposition below).

0.10.8: Z / Laplace / bilinear helpers — see Z and Laplace.

0.10.18: Mode decomposition keeps sample buffers in T via Fft<T> / HilbertTransform<T> / NaturalCubicSpline<T> (EEMD / CEEMDAN still average in double). The non-generic HilbertTransform (float) remains.

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

:ledger: Contents

All types below are in Vorcyc.Mathematics.SignalProcessing.Transforms namespace。

Mode decomposition

Namespace: Vorcyc.Mathematics.SignalProcessing.Transforms.ModeDecomposition

Adaptive / variational / spectral mode separation for real signals (float / double). Prefer the facade ModeDecomposer from apps. Every algorithm accepts optional options, CancellationToken, and IProgress<ModeDecompositionProgress>. CPU policy is set via options’ ComputingContext? (or ambient ComputingScope). From 0.10.18 VMD / MVMD / EWT / HHT / SSA / EMD / MEMD stay in T (FFT, Hilbert analytic signal, and envelope spline); they no longer promote the whole buffer to double just to call Fft64. Details: ComputingContext.

Type Role
EmpiricalModeDecomposition Classical EMD (sifting → IMFs + residual)
EnsembleEmpiricalModeDecomposition EEMD — noise ensemble average of EMD
CompleteEnsembleEmd CEEMDAN (Torres 2011): noise-mode–assisted stage-wise IMFs, exact reconstruction
VariationalModeDecomposition VMD — band-limited modes in the frequency domain
MultivariateEmpiricalModeDecomposition MEMD — multi-channel EMD
MultivariateVariationalModeDecomposition MVMD — multi-channel VMD
SingularSpectrumAnalysis SSA — trajectory matrix + SVD + grouping
EmpiricalWaveletTransform EWT — adaptive wavelet filter bank
HilbertHuangTransform Instantaneous amplitude / frequency via HilbertTransform<T> + optional sparse Hilbert spectrum
ModeDecomposer Static facade: Emd / Eemd / Ceemdan / Vmd / Hht / Instantaneous / Memd / Mvmd / Ssa / Ewt

Hilbert–Huang notes

  • HilbertHuangTransform.Analyze always runs EMD first (there is no RunEmd switch).
  • For existing modes (e.g. after VMD), use AnalyzeModes or ModeDecomposer.Instantaneous.
  • HhtOptions.AnalyzeResidual is honored by both Analyze and AnalyzeModes.

Quick example

using Vorcyc.Mathematics;
using Vorcyc.Mathematics.SignalProcessing.Transforms.ModeDecomposition;

using (ComputingScope.Enter(ComputingContext.Parallel))
{
    var emd = ModeDecomposer.Emd(signal.AsSpan());
    var ceemdan = ModeDecomposer.Ceemdan(signal.AsSpan(), new CeemdanOptions { EnsembleSize = 50 });
    var hht = ModeDecomposer.Hht(signal.AsSpan(), samplingRate: 1000f);
}

Z and Laplace

Namespace: Vorcyc.Mathematics.SignalProcessing.Transforms

Type Role
ZTransform Finite-length DTFT (Dtft), rational H(z) evaluate / FR, discrete stability (IsStable, MaxPoleRadius)
LaplaceTransform Rational H(s) (ascending powers of s), H(jω), analog stability, bilinear + inverse bilinear maps
AnalogDigitalTransform Analog poles/zeros → discrete TransferFunction (Bilinear / BilinearLowpass); InverseBilinear

Dtft / Transform / multi-ω EvaluateFrequencyResponse / LaplaceTransform.FrequencyResponse honor ComputingContext?: parallel via ForEach when the shared work gate fires; otherwise explicit Simd (or Auto→Simd) uses frequency-lane SIMD, Normal uses scalar. Explicit modes bypass Auto’s 1K/16K ladders. Single-point evaluate / stability / bilinear maps stay serial (filter order). Details: ComputingContext.

Discrete TF coefficients match TransferFunction: b0 + b1·z⁻¹ + …. Analog polys use ascending s: b0 + b1·s + …. Pre-warp cutoff is normalized frequency in (0, 0.5) (same as DesignFilter.IirLpTf).

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

var X = ZTransform.Dtft(signal, numPoints: 1024);
var tf = AnalogDigitalTransform.BilinearLowpass(0.1f, PrototypeButterworth.Poles(4));
bool ok = ZTransform.IsStable(tf.Poles);

Prefer TransferFunction.Poles / Zeros for pole-zero extraction. ZTransform.GetPolesAndZeros was removed (inferring poles/zeros from DTFT samples is incorrect).

Vorcyc.Mathematics.SignalProcessing.Transforms.Dct1 class

Vorcyc.Mathematics.SignalProcessing.Transforms.Dct1 represents discrete cosine transform type I (DCT-I).

Properties

1. Size

  • public int Size { get; }
    • Gets DCT-I size.

Methods

1. Dct1 constructor

  • public Dct1(int dctSize)
    • Constructs Dct1 for given dctSize and precomputes DCT matrix.
    • Parameters:
      • dctSize: DCT-I size.

2. Direct

  • public void Direct(float[] input, float[] output)
    • Performs DCT-I.
    • Parameters:
      • input: Input data.
      • output: Output data.

3. DirectNorm

  • public void DirectNorm(float[] input, float[] output)
    • Performs normalized DCT-I.
    • Parameters:
      • input: Input data.
      • output: Output data.

4. Inverse

  • public void Inverse(float[] input, float[] output)
    • Performs inverse DCT-I.
    • Parameters:
      • input: Input data.
      • output: Output data.

5. InverseNorm

  • public void InverseNorm(float[] input, float[] output)
    • Performs normalized inverse DCT-I.
    • Parameters:
      • input: Input data.
      • output: Output data.

Code example

The following example uses Dct1 with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Transforms;

public class Dct1Example
{
    public static void Main()
    {
        // Define DCT size
        int dctSize = 8;

        // Create Dct1 instance
        var dct = new Dct1(dctSize);

        // Define input data
        float[] input = { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f };
        float[] output = new float[dctSize];

        // Perform DCT-I
        dct.Direct(input, output);
        Console.WriteLine("DCT-I Output:");

        foreach (var value in output)
        {
            Console.WriteLine(value);
        }

        // Perform normalized DCT-I
        dct.DirectNorm(input, output);
        Console.WriteLine("Normalized DCT-I Output:");

        foreach (var value in output)
        {
            Console.WriteLine(value);
        }

        // Perform inverse DCT-I
        dct.Inverse(output, input);
        Console.WriteLine("Inverse DCT-I Output:");

        foreach (var value in input)
        {
            Console.WriteLine(value);
        }

        // Perform normalized inverse DCT-I
        dct.InverseNorm(output, input);
        Console.WriteLine("Normalized Inverse DCT-I Output:");

        foreach (var value in input)
        {
            Console.WriteLine(value);
        }
    }
}

Vorcyc.Mathematics.SignalProcessing.Transforms.Dct2 class

Vorcyc.Mathematics.SignalProcessing.Transforms.Dct2 represents DCT-II.

Properties

1. Size

  • public int Size { get; }
    • Gets DCT-II size.

Methods

1. Dct2 constructor

  • public Dct2(int dctSize)
    • Constructs Dct2 for given dctSize and precomputes DCT matrix.
    • Parameters:
      • dctSize: DCT-II size.

2. Direct

  • public void Direct(float[] input, float[] output)
    • Perform DCT-II。
    • Parameters:
      • input: Input data.
      • output: Output data.

3. DirectNorm

  • public void DirectNorm(float[] input, float[] output)
    • Perform normalized DCT-II。
    • Parameters:
      • input: Input data.
      • output: Output data.

4. Inverse

  • public void Inverse(float[] input, float[] output)
    • Perform inverse DCT-II。
    • Parameters:
      • input: Input data.
      • output: Output data.

5. InverseNorm

  • public void InverseNorm(float[] input, float[] output)
    • Perform normalized inverse DCT-II。
    • Parameters:
      • input: Input data.
      • output: Output data.

Code example

The following example uses Dct2 with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Transforms;

public class Dct2Example
{
    public static void Main()
    {
        // Define DCT size
        int dctSize = 8;

        // Create Dct2 instance
        var dct = new Dct2(dctSize);

        // Define input data
        float[] input = { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f };
        float[] output = new float[dctSize];

        // Perform DCT-II
        dct.Direct(input, output);
        Console.WriteLine("DCT-II Output:");

        foreach (var value in output)
        {
            Console.WriteLine(value);
        }

        // Perform normalized DCT-II
        dct.DirectNorm(input, output);
        Console.WriteLine("Normalized DCT-II Output:");

        foreach (var value in output)
        {
            Console.WriteLine(value);
        }

        // Perform inverse DCT-II
        dct.Inverse(output, input);
        Console.WriteLine("Inverse DCT-II Output:");

        foreach (var value in input)
        {
            Console.WriteLine(value);
        }

        // Perform normalized inverse DCT-II
        dct.InverseNorm(output, input);
        Console.WriteLine("Normalized Inverse DCT-II Output:");

        foreach (var value in input)
        {
            Console.WriteLine(value);
        }
    }
}

Vorcyc.Mathematics.SignalProcessing.Transforms.Dct3 class

Vorcyc.Mathematics.SignalProcessing.Transforms.Dct3 represents DCT-III.

Properties

1. Size

  • public int Size { get; }
    • Gets DCT-III size.

Methods

1. Dct3 constructor

  • public Dct3(int dctSize)
    • Constructs Dct3 for given dctSize and precomputes DCT matrix.
    • Parameters:
      • dctSize: DCT-III size.

2. Direct

  • public void Direct(float[] input, float[] output)
    • Perform DCT-III。
    • Parameters:
      • input: Input data.
      • output: Output data.

3. DirectNorm

  • public void DirectNorm(float[] input, float[] output)
    • Perform normalized DCT-III。
    • Parameters:
      • input: Input data.
      • output: Output data.

4. Inverse

  • public void Inverse(float[] input, float[] output)
    • Perform inverse DCT-III。
    • Parameters:
      • input: Input data.
      • output: Output data.

5. InverseNorm

  • public void InverseNorm(float[] input, float[] output)
    • Perform normalized inverse DCT-III。
    • Parameters:
      • input: Input data.
      • output: Output data.

Code example

The following example uses Dct3 with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Transforms;

public class Dct3Example
{
    public static void Main()
    {
        // Define DCT size
        int dctSize = 8;

        // Create Dct3 instance
        var dct = new Dct3(dctSize);

        // Define input data
        float[] input = { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f };
        float[] output = new float[dctSize];

        // Perform DCT-III
        dct.Direct(input, output);
        Console.WriteLine("DCT-III Output:");

        foreach (var value in output)
        {
            Console.WriteLine(value);
        }

        // Perform normalized DCT-III
        dct.DirectNorm(input, output);
        Console.WriteLine("Normalized DCT-III Output:");

        foreach (var value in output)
        {
            Console.WriteLine(value);
        }

        // Perform inverse DCT-III
        dct.Inverse(output, input);
        Console.WriteLine("Inverse DCT-III Output:");

        foreach (var value in input)
        {
            Console.WriteLine(value);
        }

        // Perform normalized inverse DCT-III
        dct.InverseNorm(output, input);
        Console.WriteLine("Normalized Inverse DCT-III Output:");

        foreach (var value in input)
        {
            Console.WriteLine(value);
        }
    }
}

Vorcyc.Mathematics.SignalProcessing.Transforms.Dct4 class

Vorcyc.Mathematics.SignalProcessing.Transforms.Dct4 represents DCT-IV.

Properties

1. Size

  • public int Size { get; }
    • Gets DCT-IV size.

Methods

1. Dct4 constructor

  • public Dct4(int dctSize)
    • Constructs Dct4 for given dctSize and precomputes DCT matrix.
    • Parameters:
      • dctSize: DCT-IV size.

2. Direct

  • public void Direct(float[] input, float[] output)
    • Perform DCT-IV。
    • Parameters:
      • input: Input data.
      • output: Output data.

3. DirectNorm

  • public void DirectNorm(float[] input, float[] output)
    • Perform normalized DCT-IV。
    • Parameters:
      • input: Input data.
      • output: Output data.

4. Inverse

  • public void Inverse(float[] input, float[] output)
    • Perform inverse DCT-IV。
    • Parameters:
      • input: Input data.
      • output: Output data.

5. InverseNorm

  • public void InverseNorm(float[] input, float[] output)
    • Perform normalized inverse DCT-IV。
    • Parameters:
      • input: Input data.
      • output: Output data.

Code example

The following example uses Dct4 with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Transforms;

public class Dct4Example
{
    public static void Main()
    {
        // Define DCT size
        int dctSize = 8;

        // Create Dct4 instance
        var dct = new Dct4(dctSize);

        // Define input data
        float[] input = { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f };
        float[] output = new float[dctSize];

        // Perform DCT-IV
        dct.Direct(input, output);
        Console.WriteLine("DCT-IV Output:");

        foreach (var value in output)
        {
            Console.WriteLine(value);
        }

        // Perform normalized DCT-IV
        dct.DirectNorm(input, output);
        Console.WriteLine("Normalized DCT-IV Output:");

        foreach (var value in output)
        {
            Console.WriteLine(value);
        }

        // Perform inverse DCT-IV
        dct.Inverse(output, input);
        Console.WriteLine("Inverse DCT-IV Output:");

        foreach (var value in input)
        {
            Console.WriteLine(value);
        }

        // Perform normalized inverse DCT-IV
        dct.InverseNorm(output, input);
        Console.WriteLine("Normalized Inverse DCT-IV Output:");

        foreach (var value in input)
        {
            Console.WriteLine(value);
        }
    }
}

Vorcyc.Mathematics.SignalProcessing.Transforms.FastDct2 class

Vorcyc.Mathematics.SignalProcessing.Transforms.FastDct2 represents DCT-II.FFT-based DCT-II; faster for large DCT sizes.

Properties

1. Size

  • public int Size { get; }
    • Gets DCT-II size.

Methods

1. FastDct2 constructor

  • public FastDct2(int dctSize)
    • Constructs FastDct2 for given dctSize.
    • Parameters:
      • dctSize: DCT-II size.

2. Direct

  • public void Direct(float[] input, float[] output)
    • Perform DCT-II。
    • Parameters:
      • input: Input data.
      • output: Output data.

3. DirectNorm

  • public void DirectNorm(float[] input, float[] output)
    • Perform normalized DCT-II。
    • Parameters:
      • input: Input data.
      • output: Output data.

4. Inverse

  • public void Inverse(float[] input, float[] output)
    • Perform inverse DCT-II。
    • Parameters:
      • input: Input data.
      • output: Output data.

5. InverseNorm

  • public void InverseNorm(float[] input, float[] output)
    • Perform normalized inverse DCT-II。
    • Parameters:
      • input: Input data.
      • output: Output data.

Code example

The following example uses FastDct2 with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Transforms;

public class FastDct2Example
{
    public static void Main()
    {
        // Define DCT size
        int dctSize = 8;

        // Create FastDct2 instance
        var dct = new FastDct2(dctSize);

        // Define input data
        float[] input = { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f };
        float[] output = new float[dctSize];

        // Perform DCT-II
        dct.Direct(input, output);
        Console.WriteLine("DCT-II Output:");

        foreach (var value in output)
        {
            Console.WriteLine(value);
        }

        // Perform normalized DCT-II
        dct.DirectNorm(input, output);
        Console.WriteLine("Normalized DCT-II Output:");

        foreach (var value in output)
        {
            Console.WriteLine(value);
        }

        // Perform inverse DCT-II
        dct.Inverse(output, input);
        Console.WriteLine("Inverse DCT-II Output:");

        foreach (var value in input)
        {
            Console.WriteLine(value);
        }

        // Perform normalized inverse DCT-II
        dct.InverseNorm(output, input);
        Console.WriteLine("Normalized Inverse DCT-II Output:");

        foreach (var value in input)
        {
            Console.WriteLine(value);
        }
    }
}

Vorcyc.Mathematics.SignalProcessing.Transforms.FastDct3 class

Vorcyc.Mathematics.SignalProcessing.Transforms.FastDct3 represents DCT-III.FFT-based DCT-III; faster for large sizes.

Properties

1. Size

  • public int Size { get; }
    • Gets DCT-III size.

Methods

1. FastDct3 constructor

  • public FastDct3(int dctSize)
    • Constructs FastDct3 for given dctSize.
    • Parameters:
      • dctSize: DCT-III size.

2. Direct

  • public void Direct(float[] input, float[] output)
    • Perform DCT-III。
    • Parameters:
      • input: Input data.
      • output: Output data.

3. DirectNorm

  • public void DirectNorm(float[] input, float[] output)
    • Perform normalized DCT-III。
    • Parameters:
      • input: Input data.
      • output: Output data.

4. Inverse

  • public void Inverse(float[] input, float[] output)
    • Perform inverse DCT-III。
    • Parameters:
      • input: Input data.
      • output: Output data.

5. InverseNorm

  • public void InverseNorm(float[] input, float[] output)
    • Perform normalized inverse DCT-III。
    • Parameters:
      • input: Input data.
      • output: Output data.

Code example

The following example uses FastDct3 with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Transforms;

public class FastDct3Example
{
    public static void Main()
    {
        // Define DCT size
        int dctSize = 8;

        // Create FastDct3 instance
        var dct = new FastDct3(dctSize);

        // Define input data
        float[] input = { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f };
        float[] output = new float[dctSize];

        // Perform DCT-III
        dct.Direct(input, output);
        Console.WriteLine("DCT-III Output:");

        foreach (var value in output)
        {
            Console.WriteLine(value);
        }

        // Perform normalized DCT-III
        dct.DirectNorm(input, output);
        Console.WriteLine("Normalized DCT-III Output:");

        foreach (var value in output)
        {
            Console.WriteLine(value);
        }

        // Perform inverse DCT-III
        dct.Inverse(output, input);
        Console.WriteLine("Inverse DCT-III Output:");

        foreach (var value in input)
        {
            Console.WriteLine(value);
        }

        // Perform normalized inverse DCT-III
        dct.InverseNorm(output, input);
        Console.WriteLine("Normalized Inverse DCT-III Output:");

        foreach (var value in input)
        {
            Console.WriteLine(value);
        }
    }
}

Vorcyc.Mathematics.SignalProcessing.Transforms.FastDct4 class

Vorcyc.Mathematics.SignalProcessing.Transforms.FastDct4 represents DCT-IV.FFT-based DCT-IV; faster for large sizes.

Properties

1. Size

  • public int Size { get; }
    • Gets DCT-IV size.

Methods

1. FastDct4 constructor

  • public FastDct4(int dctSize)
    • Constructs FastDct4 for given dctSize.
    • Parameters:
      • dctSize: DCT-IV size.

2. Direct

  • public void Direct(float[] input, float[] output)
    • Perform DCT-IV。
    • Parameters:
      • input: Input data.
      • output: Output data.

3. DirectNorm

  • public void DirectNorm(float[] input, float[] output)
    • Perform normalized DCT-IV。
    • Parameters:
      • input: Input data.
      • output: Output data.

4. Inverse

  • public void Inverse(float[] input, float[] output)
    • Perform inverse DCT-IV。
    • Parameters:
      • input: Input data.
      • output: Output data.

5. InverseNorm

  • public void InverseNorm(float[] input, float[] output)
    • Perform normalized inverse DCT-IV。
    • Parameters:
      • input: Input data.
      • output: Output data.

Code example

The following example uses FastDct4 with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Transforms;

public class FastDct4Example
{
    public static void Main()
    {
        // Define DCT size
        int dctSize = 8;

        // Create FastDct4 instance
        var dct = new FastDct4(dctSize);

        // Define input data
        float[] input = { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f };
        float[] output = new float[dctSize];

        // Perform DCT-IV
        dct.Direct(input, output);
        Console.WriteLine("DCT-IV Output:");

        foreach (var value in output)
        {
            Console.WriteLine(value);
        }

        // Perform normalized DCT-IV
        dct.DirectNorm(input, output);
        Console.WriteLine("Normalized DCT-IV Output:");

        foreach (var value in output)
        {
            Console.WriteLine(value);
        }

        // Perform inverse DCT-IV
        dct.Inverse(output, input);
        Console.WriteLine("Inverse DCT-IV Output:");

        foreach (var value in input)
        {
            Console.WriteLine(value);
        }

        // Perform normalized inverse DCT-IV
        dct.InverseNorm(output, input);
        Console.WriteLine("Normalized Inverse DCT-IV Output:");

        foreach (var value in input)
        {
            Console.WriteLine(value);
        }
    }
}

Vorcyc.Mathematics.SignalProcessing.Transforms.FastMdct class

Vorcyc.Mathematics.SignalProcessing.Transforms.FastMdct represents modified discrete cosine transform (MDCT).FFT-based MDCT; faster for large sizes.

Methods

1. FastMdct constructor

  • public FastMdct(int dctSize)
    • Constructs FastMdct for given dctSize.
    • Parameters:
      • dctSize: MDCT size.

Code example

The following example uses FastMdct with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Transforms;

public class FastMdctExample
{
    public static void Main()
    {
        // Define MDCT size
        int dctSize = 8;

        // Create FastMdct instance
        var mdct = new FastMdct(dctSize);

        // Define input data
        float[] input = { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f };
        float[] output = new float[dctSize];

        // Perform MDCT
        mdct.Direct(input, output);
        Console.WriteLine("MDCT Output:");

        foreach (var value in output)
        {
            Console.WriteLine(value);
        }

        // Perform inverse MDCT
        mdct.Inverse(output, input);
        Console.WriteLine("Inverse MDCT Output:");

        foreach (var value in input)
        {
            Console.WriteLine(value);
        }
    }
}

Vorcyc.Mathematics.SignalProcessing.Transforms.Mdct class

Vorcyc.Mathematics.SignalProcessing.Transforms.Mdct represents modified discrete cosine transform (MDCT).

Properties

1. Size

  • public int Size { get; }
    • Gets MDCT size.

Methods

1. Mdct constructor

  • public Mdct(int dctSize, IDct dct = null)
    • Constructs Mdct for given dctSize.
    • Parameters:
      • dctSize: MDCT size.
      • dct: Internal DCT transformer (default Dct4).

2. Direct

  • public void Direct(float[] input, float[] output)
    • Performs MDCT. input length must be 2 * Mdct.Size; output length must be Mdct.Size.
    • Parameters:
      • input: Input data.
      • output: Output data.

3. DirectNorm

  • public void DirectNorm(float[] input, float[] output)
    • Performs normalized MDCT. Same length constraints.
    • Parameters:
      • input: Input data.
      • output: Output data.

4. Inverse

  • public void Inverse(float[] input, float[] output)
    • Performs inverse MDCT. input length must be Mdct.Size; output length must be 2 * Mdct.Size.
    • Parameters:
      • input: Input data.
      • output: Output data.

5. InverseNorm

  • public void InverseNorm(float[] input, float[] output)
    • Performs normalized inverse MDCT. Same length constraints.
    • Parameters:
      • input: Input data.
      • output: Output data.

Code example

The following example uses Mdct with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Transforms;
public class MdctExample
{
    public static void Main()
    {
        // Define MDCT size
        int dctSize = 8;

        // Create Mdct instance
        var mdct = new Mdct(dctSize);

        // Define input data
        float[] input = { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f };
        float[] output = new float[dctSize];

        // Perform MDCT
        mdct.Direct(input, output);
        Console.WriteLine("MDCT Output:");

        foreach (var value in output)
        {
            Console.WriteLine(value);
        }

        // Perform normalized MDCT
        mdct.DirectNorm(input, output);
        Console.WriteLine("Normalized MDCT Output:");

        foreach (var value in output)
        {
            Console.WriteLine(value);
        }

        // Perform inverse MDCT
        mdct.Inverse(output, input);
        Console.WriteLine("Inverse MDCT Output:");

        foreach (var value in input)
        {
            Console.WriteLine(value);
        }

        // Perform normalized inverse MDCT
        mdct.InverseNorm(output, input);
        Console.WriteLine("Normalized Inverse MDCT Output:");

        foreach (var value in input)
        {
            Console.WriteLine(value);
        }
    }
}