Module_SignalProcessing_Operations

Location: Home / Signal processing / Operations

Signal Processing Module

Operations

The Vorcyc.Mathematics.SignalProcessing.Operations namespace includes common signal-processing operations: convolution (ComplexConvolver, Convolver, OlaBlockConvolver, OlsBlockConvolver), dynamics (DynamicsProcessor), envelope following (EnvelopeFollower), reconstruction (GriffinLimReconstructor), harmonic/percussive separation (HarmonicPercussiveSeparator), modulation (Modulator), general utilities (Operation), resampling (Resampler), spectral subtraction (SpectralSubtractor), and waveshaping (WaveShaper). These types support a wide range of audio and signal-processing tasks.

0.9 API note: Preferred overloads for the types below accept Signal (return Signal or write to Signal.Samples). Operation.Convolve, CrossCorrelate, BlockConvolve, Resample, TimeStretch, Envelope, FullRectify, HalfRectify, SpectralSubtract, and others have Signal versions; Convolver / Modulator / SpectralSubtractor use zero-copy ReadOnlySpan<float> internally. DiscreteSignal is [Obsolete]; use Signal (sample rate as float). ComplexDiscreteSignalFp32 is retained for complex-valued operations.

0.10.19: Convolver<T> / OlaBlockConvolver<T> / OlsBlockConvolver<T> / ComplexConvolver<T> and Operation.Convolve<T> / CrossCorrelate<T> / BlockConvolve<T> take float / double (N+M-1). Classic float types unchanged; OLA/OLS IEnumerable<double> ctors still cast.

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

📒 Contents

🔖 Vorcyc.Mathematics.SignalProcessing.Operations.Convolution.ComplexConvolver class
🔖 Vorcyc.Mathematics.SignalProcessing.Operations.Convolution.Convolver class
🔖 Vorcyc.Mathematics.SignalProcessing.Operations.Convolution.Convolver<T> / Convolver64
🔖 Vorcyc.Mathematics.SignalProcessing.Operations.Convolution.OlaBlockConvolver class
🔖 Vorcyc.Mathematics.SignalProcessing.Operations.Convolution.OlsBlockConvolver class
🔖 Vorcyc.Mathematics.SignalProcessing.Operations.DynamicsMode enum
🔖 Vorcyc.Mathematics.SignalProcessing.Operations.DynamicsProcessor class
🔖 Vorcyc.Mathematics.SignalProcessing.Operations.EnvelopeFollower class
🔖 Vorcyc.Mathematics.SignalProcessing.Operations.GriffinLimReconstructor class
🔖 Vorcyc.Mathematics.SignalProcessing.Operations.HarmonicPercussiveSeparator class
🔖 Vorcyc.Mathematics.SignalProcessing.Operations.Modulator class
🔖 Vorcyc.Mathematics.SignalProcessing.Operations.Operation class
🔖 Vorcyc.Mathematics.SignalProcessing.Operations.Resampler class
🔖 Vorcyc.Mathematics.SignalProcessing.Operations.SpectralSubtractor class
🔖 Vorcyc.Mathematics.SignalProcessing.Operations.WaveShaper class

All types below are in namespace: Vorcyc.Mathematics.SignalProcessing.Operations.Convolution

Vorcyc.Mathematics.SignalProcessing.Operations.Convolution.ComplexConvolver class

Vorcyc.Mathematics.SignalProcessing.Operations.Convolution.ComplexConvolver performs fast convolution (FFT) with complex-valued input/output.

Methods

1. Convolve

public ComplexDiscreteSignalFp32 Convolve(ComplexDiscreteSignalFp32 signal, ComplexDiscreteSignalFp32 kernel, int fftSize = 0)
- Uses FFT for fast convolution of signal and kernel.
- Parameters:
  - signal: input signal.
  - kernel: kernel.
  - fftSize: FFT size; default 0.
- Returns: ComplexDiscreteSignalFp32 convolution result.

2. CrossCorrelate

public ComplexDiscreteSignalFp32 CrossCorrelate(ComplexDiscreteSignalFp32 signal, ComplexDiscreteSignalFp32 kernel, int fftSize = 0)
- Uses FFT for fast cross-correlation of signal and kernel.
- Parameters:
  - signal: input signal.
  - kernel: kernel.
  - fftSize: FFT size; default 0.
- Returns: ComplexDiscreteSignalFp32 cross-correlation result.

3. Deconvolve

public ComplexDiscreteSignalFp32 Deconvolve(ComplexDiscreteSignalFp32 signal, ComplexDiscreteSignalFp32 kernel, int fftSize = 0)
- Uses polynomial division and FFT for fast deconvolution of signal and kernel.
- Parameters:
  - signal: input signal.
  - kernel: kernel.
  - fftSize: FFT size; default 0.
- Returns: ComplexDiscreteSignalFp32 deconvolution result.

Code example

The following example uses ComplexConvolver with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Operations.Convolution;

public class ComplexConvolverExample
{
    public static void Main()
    {
        // Create ComplexConvolver instance
        var convolver = new ComplexConvolver();

        // Define input signal and kernel
        var signal = new ComplexDiscreteSignalFp32(44100, new float[] { 0.5f, 0.6f, 0.55f }, new float[] { 0.1f, 0.2f, 0.15f });
        var kernel = new ComplexDiscreteSignalFp32(44100, new float[] { 0.3f, 0.4f }, new float[] { 0.05f, 0.1f });

        // Run convolution
        var convolvedSignal = convolver.Convolve(signal, kernel);
        Console.WriteLine("Convolved Signal:");
        for (int i = 0; i < convolvedSignal.Length; i++)
        {
            Console.WriteLine($"Real: {convolvedSignal.Real[i]}, Imaginary: {convolvedSignal.Imag[i]}");
        }

        // Run cross-correlation
        var crossCorrelatedSignal = convolver.CrossCorrelate(signal, kernel);
        Console.WriteLine("Cross-Correlated Signal:");
        for (int i = 0; i < crossCorrelatedSignal.Length; i++)
        {
            Console.WriteLine($"Real: {crossCorrelatedSignal.Real[i]}, Imaginary: {crossCorrelatedSignal.Imag[i]}");
        }

        // Run deconvolution
        var deconvolvedSignal = convolver.Deconvolve(signal, kernel);
        Console.WriteLine("Deconvolved Signal:");
        for (int i = 0; i < deconvolvedSignal.Length; i++)
        {
            Console.WriteLine($"Real: {deconvolvedSignal.Real[i]}, Imaginary: {deconvolvedSignal.Imag[i]}");
        }
    }
}

Vorcyc.Mathematics.SignalProcessing.Operations.Convolution.Convolver class

Vorcyc.Mathematics.SignalProcessing.Operations.Convolution.Convolver performs fast convolution (FFT).

Methods

1. Convolve

public Signal Convolve(Signal signal, Signal kernel)
- Uses FFT for fast convolution of signal and kernel.
- Parameters:
  - signal: input signal.
  - kernel: kernel.
- Returns: convolution result Signal.
public void Convolve(float[] input, float[] kernel, float[] output)
- Uses FFT for fast convolution of input and kernel; stores result in output array.
- Parameters:
  - input: input signal array..
  - kernel: kernel array..
  - output: output result array..

2. CrossCorrelate

public Signal CrossCorrelate(Signal signal1, Signal signal2)
- Uses FFT for fast cross-correlation of signal1 and signal2.
- Parameters:
  - signal1: input signal1.
  - signal2: input signal2.
- Returns: cross-correlation result Signal.
public void CrossCorrelate(float[] input1, float[] input2, float[] output)
- Uses FFT for fast cross-correlation of input1 and input2; stores result in output array.
- Parameters:
  - input1: input signal array 1..
  - input2: input signal array 2..
  - output: output result array..

Code example

The following example uses Convolver with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Operations.Convolution;
using Vorcyc.Mathematics.SignalProcessing.Signals;

public class ConvolverExample
{
    public static void Main()
    {
        // Create Convolver instance
        var convolver = new Convolver();

        // Define input signal and kernel
        var signal = Signal.FromCopy(new float[] { 0.5f, 0.6f, 0.55f }, 44100);
        var kernel = Signal.FromCopy(new float[] { 0.3f, 0.4f }, 44100);

        // Run convolution
        var convolvedSignal = convolver.Convolve(signal, kernel);
        Console.WriteLine("Convolved Signal:");
        for (int i = 0; i < convolvedSignal.Length; i++)
        {
            Console.WriteLine($"Sample: {convolvedSignal[i]}");
        }

        // Run cross-correlation
        var crossCorrelatedSignal = convolver.CrossCorrelate(signal, kernel);
        Console.WriteLine("Cross-Correlated Signal:");
        for (int i = 0; i < crossCorrelatedSignal.Length; i++)
        {
            Console.WriteLine($"Sample: {crossCorrelatedSignal[i]}");
        }
    }
}

Vorcyc.Mathematics.SignalProcessing.Operations.Convolution.Convolver<T> / Convolver64

Convolver<T> (0.10.19) is the FFT conv / xcorr kernel for float and double. Convolver64 is Convolver<double>. Result length is N + M - 1. Inputs are not mutated.

double[] y = new Convolver<double>().Convolve(x, kernel);
double[] r = Operation.CrossCorrelate(x, kernel);
double[] b = new OlaBlockConvolver64(kernel, 64).ApplyTo(x);
var z = new ComplexConvolver<double>().Convolve(a, k);

Vorcyc.Mathematics.SignalProcessing.Operations.Convolution.OlaBlockConvolver class

Vorcyc.Mathematics.SignalProcessing.Operations.Convolution.OlaBlockConvolver is a block convolver using the overlap-add algorithm.

Properties

1. HopSize

public int HopSize { get; }
- Gets hop length: FFT size - kernel size + 1.

Methods

1. OlaBlockConvolver constructor

public OlaBlockConvolver(IEnumerable<float> kernel, int fftSize)
- Constructs OlaBlockConvolver with kernel and FFT size.
- Parameters:
  - kernel: kernel.
  - fftSize: FFT size.
public OlaBlockConvolver(IEnumerable<double> kernel, int fftSize)
- Constructs OlaBlockConvolver with kernel and FFT size.
- Parameters:
  - kernel: kernel.
  - fftSize: FFT size.
public static OlaBlockConvolver FromFilter(FirFilter filter, int fftSize)
- Constructs OlaBlockConvolver from FIR kernel and FFT size.
- Parameters:
  - filter: FIR filter.
  - fftSize: FFT size.
- Returns: OlaBlockConvolver instance.

2. ChangeKernel

public void ChangeKernel(float[] kernel)
- Changes kernel coefficients online.
- Parameters:
  - kernel: new kernel..

3. Process

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

4. ApplyTo

public Signal ApplyTo(Signal 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 Signal.

5. Reset

public void Reset()
- Resets overlap-add convolver.

Code example

The following example uses OlaBlockConvolver with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Operations.Convolution;
using Vorcyc.Mathematics.SignalProcessing.Signals;

public class OlaBlockConvolverExample
{
    public static void Main()
    {
        // Define kernel and FFT size
        float[] kernel = { 0.3f, 0.4f, 0.5f }; int fftSize = 8;

        // Create OlaBlockConvolver instance
        var convolver = new OlaBlockConvolver(kernel, fftSize);

        // Define input signal
        float[] inputSignal = { 0.5f, 0.6f, 0.55f, 0.7f, 0.65f, 0.8f, 0.75f, 0.9f };

        // Process entire signal
        var outputSignal = convolver.ApplyTo(Signal.FromCopy(inputSignal, 44100));
        Console.WriteLine("Filtered Signal:");
        foreach (var sample in outputSignal.Samples)
        {
            Console.WriteLine($"Sample: {sample}");
        }

        // Change kernel online
        float[] newKernel = { 0.2f, 0.3f, 0.4f };
        convolver.ChangeKernel(newKernel);

        // Process single sample
        float processedSample = convolver.Process(0.85f);
        Console.WriteLine($"Processed Sample: {processedSample}");

        // Reset convolver
        convolver.Reset();
    }
}

Vorcyc.Mathematics.SignalProcessing.Operations.Convolution.OlsBlockConvolver class

Vorcyc.Mathematics.SignalProcessing.Operations.Convolution.OlsBlockConvolver is a block convolver using the overlap-save algorithm.

Properties

1. HopSize

public int HopSize { get; }
- Gets hop length: FFT size - kernel size + 1.

Methods

1. OlsBlockConvolver constructor

public OlsBlockConvolver(IEnumerable<float> kernel, int fftSize)
- Constructs OlsBlockConvolver with kernel and FFT size.
- Parameters:
  - kernel: kernel.
  - fftSize: FFT size.
public OlsBlockConvolver(IEnumerable<double> kernel, int fftSize)
- Constructs OlsBlockConvolver with kernel and FFT size.
- Parameters:
  - kernel: kernel.
  - fftSize: FFT size.
public static OlsBlockConvolver FromFilter(FirFilter filter, int fftSize)
- Constructs OlsBlockConvolver from FIR kernel and FFT size.
- Parameters:
  - filter: FIR filter.
  - fftSize: FFT size.
- Returns: OlsBlockConvolver instance.

2. ChangeKernel

public void ChangeKernel(float[] kernel)
- Changes kernel coefficients online.
- Parameters:
  - kernel: new kernel..

3. Process

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

4. ApplyTo

public Signal ApplyTo(Signal 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 Signal.

5. Reset

public void Reset()
- Resets overlap-save convolver.

Code example

The following example uses OlsBlockConvolver with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Operations.Convolution;
using Vorcyc.Mathematics.SignalProcessing.Signals;

public class OlsBlockConvolverExample
{
    public static void Main()
    {
        // Define kernel and FFT size
        float[] kernel = { 0.3f, 0.4f, 0.5f }; int fftSize = 8;

        // Create OlsBlockConvolver instance
        var convolver = new OlsBlockConvolver(kernel, fftSize);

        // Define input signal
        float[] inputSignal = { 0.5f, 0.6f, 0.55f, 0.7f, 0.65f, 0.8f, 0.75f, 0.9f };

        // Process entire signal
        var outputSignal = convolver.ApplyTo(Signal.FromCopy(inputSignal, 44100));
        Console.WriteLine("Filtered Signal:");
        foreach (var sample in outputSignal.Samples)
        {
            Console.WriteLine($"Sample: {sample}");
        }

        // Change kernel online
        float[] newKernel = { 0.2f, 0.3f, 0.4f };
        convolver.ChangeKernel(newKernel);

        // Process single sample
        float processedSample = convolver.Process(0.85f);
        Console.WriteLine($"Processed Sample: {processedSample}");

        // Reset convolver
        convolver.Reset();
    }
}

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

Vorcyc.Mathematics.SignalProcessing.Operations.DynamicsMode enum

Vorcyc.Mathematics.SignalProcessing.Operations.DynamicsMode enum defines dynamics processor types (modes).

Enum members

1. Compressor

Compressor
- Lower compression ratio, e.g. 1:1, 2:1.

2. Limiter

Limiter
- Higher compression ratio, e.g. 5:1, 10:1.

3. Expander

Expander
- Lower expansion ratio, e.g. 1:1, 2:1.

4. NoiseGate

NoiseGate
- Very high compression ratio, e.g. 5:1.
Vorcyc.Mathematics.SignalProcessing.Operations.DynamicsProcessor class

Vorcyc.Mathematics.SignalProcessing.Operations.DynamicsProcessor implements dynamics processing (limiter, compressor, expander, or noise gate).

Properties

1. Threshold

public float Threshold { get; set; }
- Gets or sets compression/expansion threshold.

2. Ratio

public float Ratio { get; set; }
- Gets or sets compression/expansion ratio.

3. MakeupGain

public float MakeupGain { get; set; }
- Gets or setsmakeup gain.

4. Attack

public float Attack { get; set; }
- Gets or setsattack time.

5. Release

public float Release { get; set; }
- Gets or setsrelease time.

Methods

1. DynamicsProcessor constructor

public DynamicsProcessor(DynamicsMode mode, int samplingRate, float threshold, float ratio, float makeupGain = 0, float attack = 0.01f, float release = 0.1f, float minAmplitudeDb = -120)
- Constructs DynamicsProcessor with mode, sample rate, threshold, ratio, makeup gain, attack, release, and minimum amplitude threshold.
- Parameters:
  - mode: dynamics processor mode..
  - samplingRate: sample rate.
  - threshold: compression/expansion threshold..
  - ratio: compression/expansion ratio..
  - makeupGain: makeup gain, default 0..
  - attack: attack time, default 0.01 seconds..
  - release: release time, default 0.1 seconds..
  - minAmplitudeDb: minimum amplitude threshold, default -120 dB..

2. Process

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

3. Reset

public void Reset()
- Resets dynamics processor.

4. ApplyTo

public Signal ApplyTo(Signal signal, FilteringMethod method = FilteringMethod.Auto)
- Processes entire signal and returns dynamics-processed signal.
- Parameters:
  - signal: input signal.
  - method: filtering method, default FilteringMethod.Auto..
- Returns: processed Signal.

Code example

The following example uses DynamicsProcessor with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Operations;
using Vorcyc.Mathematics.SignalProcessing.Signals;

public class DynamicsProcessorExample
{
    public static void Main()
    {
        // Define dynamics processor mode
        DynamicsMode mode = DynamicsMode.Compressor;

        // Create DynamicsProcessor instance
        var processor = new DynamicsProcessor(mode, 44100, -20, 2, 0, 0.01f, 0.1f);

        // Define input signal
        float[] inputSignal = { 0.5f, 0.6f, 0.55f, 0.7f, 0.65f, 0.8f, 0.75f, 0.9f };

        // Process entire signal
        var outputSignal = processor.ApplyTo(Signal.FromCopy(inputSignal, 44100));
        Console.WriteLine("Processed Signal:");
        foreach (var sample in outputSignal.Samples)
        {
            Console.WriteLine($"Sample: {sample}");
        }

        // Process single sample
        float processedSample = processor.Process(0.85f);
        Console.WriteLine($"Processed Sample: {processedSample}");

        // Reset dynamics processor
        processor.Reset();
    }
}

Vorcyc.Mathematics.SignalProcessing.Operations.EnvelopeFollower class

Vorcyc.Mathematics.SignalProcessing.Operations.EnvelopeFollower implements envelope following (envelope detection).

Properties

1. AttackTime

public float AttackTime { get; set; }
- Gets or sets attack time (seconds).

2. ReleaseTime

public float ReleaseTime { get; set; }
- Gets or sets release time (seconds).

Methods

1. EnvelopeFollower constructor

public EnvelopeFollower(int samplingRate, float attackTime = 0.01f, float releaseTime = 0.05f)
- Constructs EnvelopeFollower with sample rate, attack time, and release time.
- Parameters:
  - samplingRate: sample rate.
  - attackTime: attack time, default 0.01 seconds..
  - releaseTime: release time, default 0.05 seconds..

2. Process

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

3. Reset

public void Reset()
- Resets envelope follower.

4. ApplyTo

public Signal ApplyTo(Signal signal, FilteringMethod method = FilteringMethod.Auto)
- Processes entire signal and returns envelope signal.
- Parameters:
  - signal: input signal.
  - method: filtering method, default FilteringMethod.Auto..
- Returns: processed Signal.

Code example

The following example uses EnvelopeFollower with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Operations;
using Vorcyc.Mathematics.SignalProcessing.Signals;

public class EnvelopeFollowerExample
{
    public static void Main()
    {
        // Create EnvelopeFollower instance
        var envelopeFollower = new EnvelopeFollower(44100, 0.01f, 0.05f);

        // Define input signal
        float[] inputSignal = { 0.5f, 0.6f, 0.55f, 0.7f, 0.65f, 0.8f, 0.75f, 0.9f };

        // Process entire signal
        var outputSignal = envelopeFollower.ApplyTo(Signal.FromCopy(inputSignal, 44100));
        Console.WriteLine("Envelope Signal:");
        foreach (var sample in outputSignal.Samples)
        {
            Console.WriteLine($"Sample: {sample}");
        }

        // Process single sample
        float processedSample = envelopeFollower.Process(0.85f);
        Console.WriteLine($"Processed Sample: {processedSample}");

        // Reset envelope follower
        envelopeFollower.Reset();
    }
}

Vorcyc.Mathematics.SignalProcessing.Operations.GriffinLimReconstructor class

Vorcyc.Mathematics.SignalProcessing.Operations.GriffinLimReconstructor reconstructs signals from power (or magnitude) spectrograms using the Griffin–Lim algorithm.

Properties

1. Gain

public float Gain { get; set; }
- Gets or sets magnitude gain factor.

Methods

1. GriffinLimReconstructor constructor

public GriffinLimReconstructor(List<float[]> spectrogram, int windowSize = 1024, int hopSize = 256, WindowType window = WindowType.Hann, int power = 2)
- Constructs GriffinLimReconstructor with spectrogram, window size, hop size, window type, and power.
- Parameters:
  - spectrogram: spectrogram (list of spectra)..
  - windowSize: window size; default 1024..
  - hopSize: hop size; default 256..
  - window: window type; default WindowType.Hann..
  - power: power (2 = power spectrum, else magnitude spectrum); default 2..
public GriffinLimReconstructor(List<float[]> spectrogram, Stft stft, int power = 2)
- Constructs GriffinLimReconstructor with spectrogram, STFT transformer, and power.
- Parameters:
  - spectrogram: spectrogram (list of spectra)..
  - stft: STFT transformer..
  - power: power (2 = power spectrum, else magnitude spectrum); default 2..

2. Iterate

public float[] Iterate(float[] signal = null)
- Performs one reconstruction iteration and returns signal for current step.
- Parameters:
  - signal: signal from previous iteration; default null..
- Returns: reconstructed signal for current step.

3. Reconstruct

public float[] Reconstruct(int iterations = 20)
- Iteratively reconstructs signal from spectrogram.
- Parameters:
  - iterations: Griffin–Lim iteration count; default 20..
- Returns: reconstructed signal.

Code example

The following example uses GriffinLimReconstructor with comments:

using System;
using System.Collections.Generic;
using Vorcyc.Mathematics.SignalProcessing.Operations;

public class GriffinLimReconstructorExample
{
    public static void Main()
    {
        // Define spectrogram
        var spectrogram = new List<float[]> { new float[] { 0.5f, 0.6f, 0.55f }, new float[] { 0.7f, 0.65f, 0.8f }, new float[] { 0.75f, 0.9f, 0.85f } };

        // Create GriffinLimReconstructor instance
        var reconstructor = new GriffinLimReconstructor(spectrogram);

        // Run reconstruction
        var reconstructedSignal = reconstructor.Reconstruct();
        Console.WriteLine("Reconstructed Signal:");
        foreach (var sample in reconstructedSignal)
        {
            Console.WriteLine($"Sample: {sample}");
        }

        // Run one iteration
        var iteratedSignal = reconstructor.Iterate(reconstructedSignal);
        Console.WriteLine("Iterated Signal:");
        foreach (var sample in iteratedSignal)
        {
            Console.WriteLine($"Sample: {sample}");
        }
    }
}

Vorcyc.Mathematics.SignalProcessing.Operations.HarmonicPercussiveSeparator class

Vorcyc.Mathematics.SignalProcessing.Operations.HarmonicPercussiveSeparator is a median-filtering-based harmonic/percussive separator.

Methods

1. HarmonicPercussiveSeparator constructor

public HarmonicPercussiveSeparator(int fftSize = 2048, int hopSize = 512, int harmonicWinSize = 17, int percussiveWinSize = 17, HpsMasking masking = HpsMasking.WienerOrder2)
- Constructs HarmonicPercussiveSeparator with FFT size, hop length, harmonic/percussive median filter sizes, and masking mode.
- Parameters:
  - fftSize: FFT size; default 2048.
  - hopSize: hop length (samples); default 512..
  - harmonicWinSize: median filter size along time axis; default 17..
  - percussiveWinSize: median filter size along frequency axis; default 17..
  - masking: masking mode; default HpsMasking.WienerOrder2..
- The masking parameter uses the HpsMasking enum (Binary, WienerOrder1, WienerOrder2), which selects how harmonic/percussive components are masked after median filtering.

2. EvaluateSpectrograms

public (MagnitudePhaseList, MagnitudePhaseList) EvaluateSpectrograms(Signal signal)
- Evaluates harmonic and percussive magnitude-phase spectrograms from signal; both share the same phase array.
- Parameters:
  - signal: input signal.
- Returns: tuple of harmonic and percussive spectrograms.

3. EvaluateSignals

public (Signal, Signal) EvaluateSignals(Signal signal)
- Extracts harmonic and percussive signals from given signal.
- Parameters:
  - signal: input signal.
- Returns: tuple of harmonic and percussive signals.

Code example

The following example uses HarmonicPercussiveSeparator with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Operations;
using Vorcyc.Mathematics.SignalProcessing.Signals;

public class HarmonicPercussiveSeparatorExample
{
    public static void Main()
    {
        // Create HarmonicPercussiveSeparator instance
        var separator = new HarmonicPercussiveSeparator();

        // Define input signal
        float[] inputSignal = { 0.5f, 0.6f, 0.55f, 0.7f, 0.65f, 0.8f, 0.75f, 0.9f };
        var signal = Signal.FromCopy(inputSignal, 44100);

        // Evaluate spectrograms
        var (harmonicSpectrogram, percussiveSpectrogram) = separator.EvaluateSpectrograms(signal);
        Console.WriteLine("Harmonic and Percussive Spectrograms evaluated.");

        // Extract harmonic and percussive signals
        var (harmonicSignal, percussiveSignal) = separator.EvaluateSignals(signal);
        Console.WriteLine("Harmonic and Percussive Signals extracted.");

        // Print harmonicsignal
        Console.WriteLine("Harmonic Signal:");
        foreach (var sample in harmonicSignal.Samples)
        {
            Console.WriteLine($"Sample: {sample}");
        }

        // Print percussivesignal
        Console.WriteLine("Percussive Signal:");
        foreach (var sample in percussiveSignal.Samples)
        {
            Console.WriteLine($"Sample: {sample}");
        }
    }
}

Vorcyc.Mathematics.SignalProcessing.Operations.Modulator class

Vorcyc.Mathematics.SignalProcessing.Operations.Modulator provides several modulation methods:

Methods

1. Ring

public static Signal Ring(Signal carrier, Signal modulator)
- Performs ring modulation (RM) and returns RM signal.
- Parameters:
  - carrier: carrier signal.
  - modulator: modulator signal.
- Returns: modulated Signal.

2. Amplitude

public static Signal Amplitude(Signal carrier, float modulatorFrequency = 20, float modulationIndex = 0.5f)
- Performs amplitude modulation (AM) and returns AM signal.
- Parameters:
  - carrier: carrier signal.
  - modulatorFrequency: modulationfrequency, default 20 Hz.
  - modulationIndex: modulation index (depth); default 0.5..
- Returns: modulated Signal.

3. Frequency

public static Signal Frequency(Signal baseband, float carrierAmplitude, float carrierFrequency, float deviation = 0.1f)
- Performs frequency modulation (FM) and returns FM signal.
- Parameters:
  - baseband: baseband signal..
  - carrierAmplitude: carrier amplitude..
  - carrierFrequency: carrier frequency..
  - deviation: frequency deviation; default 0.1 Hz..
- Returns: modulated Signal.

4. FrequencySinusoidal

public static Signal FrequencySinusoidal(float carrierFrequency, float carrierAmplitude, float modulatorFrequency, float modulationIndex, int length, int samplingRate = 1)
- Performs sinusoidal FM and returns FM signal.
- Parameters:
  - carrierFrequency: carrier frequency..
  - carrierAmplitude: carrier amplitude..
  - modulatorFrequency: modulationfrequency.
  - modulationIndex: Modulation index (depth).
  - length: FM signal length..
  - samplingRate: sample rate, default 1.
- Returns: modulated Signal.

5. FrequencyLinear

public static Signal FrequencyLinear(float carrierFrequency, float carrierAmplitude, float modulationIndex, int length, int samplingRate = 1)
- Performs linear FM and returns FM signal.
- Parameters:
  - carrierFrequency: carrier frequency..
  - carrierAmplitude: carrier amplitude..
  - modulationIndex: Modulation index (depth).
  - length: FM signal length..
  - samplingRate: sample rate, default 1.
- Returns: modulated Signal.

6. Phase

public static Signal Phase(Signal baseband, float carrierAmplitude, float carrierFrequency, float deviation = 0.8f)
- Performs phase modulation (PM) and returns PM signal.
- Parameters:
  - baseband: baseband signal..
  - carrierAmplitude: carrier amplitude..
  - carrierFrequency: carrier frequency..
  - deviation: frequency deviation; default 0.8..
- Returns: modulated Signal.

7. DemodulateAmplitude

public static Signal DemodulateAmplitude(Signal signal)
- Simple amplitude demodulation via Hilbert transform.
- Parameters:
  - signal: input signal.
- Returns: demodulated Signal.

8. DemodulateFrequency

public static Signal DemodulateFrequency(Signal signal)
- Simple frequency demodulation via Hilbert transform.
- Parameters:
  - signal: input signal.
- Returns: demodulated Signal.

Code example

The following example uses Modulator with comments:

using System;
using System.Threading;
using Vorcyc.Mathematics.SignalProcessing.Operations;
using Vorcyc.Mathematics.SignalProcessing.Signals;

public class ModulatorExample
{
    public static void Main()
    {
        // Define carrier and modulator signals
        var carrier = Signal.FromCopy(new float[] { 0.5f, 0.6f, 0.55f }, 44100);
        var modulator = Signal.FromCopy(new float[] { 0.3f, 0.4f, 0.35f }, 44100);

        // Perform ring modulation
        var ringModulatedSignal = Modulator.Ring(carrier, modulator);
        Console.WriteLine("Ring Modulated Signal:");
        foreach (var sample in ringModulatedSignal.Samples)
        {
            Console.WriteLine($"Sample: {sample}");
        }

        // Run amplitudemodulation
        var amplitudeModulatedSignal = Modulator.Amplitude(carrier);
        Console.WriteLine("Amplitude Modulated Signal:");
        foreach (var sample in amplitudeModulatedSignal.Samples)
        {
            Console.WriteLine($"Sample: {sample}");
        }

        // Run frequencymodulation
        var frequencyModulatedSignal = Modulator.Frequency(carrier, 1.0f, 1000.0f);
        Console.WriteLine("Frequency Modulated Signal:");
        foreach (var sample in frequencyModulatedSignal.Samples)
        {
            Console.WriteLine($"Sample: {sample}");
        }

        // Run phasemodulation
        var phaseModulatedSignal = Modulator.Phase(carrier, 1.0f, 1000.0f);
        Console.WriteLine("Phase Modulated Signal:");
        foreach (var sample in phaseModulatedSignal.Samples)
        {
            Console.WriteLine($"Sample: {sample}");
        }

        // Performsamplitudedemodulation
        var demodulatedAmplitudeSignal = Modulator.DemodulateAmplitude(amplitudeModulatedSignal);
        Console.WriteLine("Demodulated Amplitude Signal:");
        foreach (var sample in demodulatedAmplitudeSignal.Samples)
        {
            Console.WriteLine($"Sample: {sample}");
        }

        // Performsfrequencydemodulation
        var demodulatedFrequencySignal = Modulator.DemodulateFrequency(frequencyModulatedSignal);
        Console.WriteLine("Demodulated Frequency Signal:");
        foreach (var sample in demodulatedFrequencySignal.Samples)
        {
            Console.WriteLine($"Sample: {sample}");
        }
    }
}

Vorcyc.Mathematics.SignalProcessing.Operations.Operation class

Vorcyc.Mathematics.SignalProcessing.Operations.Operation provides DSP/audio operation methods:

Methods

1. Convolve

public static Signal Convolve(Signal signal, Signal kernel)
- Uses FFT for fast convolution of signal and kernel.
- Parameters:
  - signal: input signal.
  - kernel: kernel.
- Returns: convolution result Signal.
public static ComplexDiscreteSignalFp32 Convolve(ComplexDiscreteSignalFp32 signal, ComplexDiscreteSignalFp32 kernel)
- Uses FFT for fast convolution of signal and kernel.
- Parameters:
  - signal: input signal.
  - kernel: kernel.
- Returns: ComplexDiscreteSignalFp32 convolution result.
public static float[] Convolve(float[] signal, float[] kernel)
- Uses FFT for fast convolution of signal and kernel.
- Parameters:
  - signal: input signal array..
  - kernel: kernel array..
- Returns: convolution result array.
public static T[] Convolve<T>(T[] signal, T[] kernel, ComputingContext? context = null)
- 0.10.19: FFT convolution in T (float / double). Length N + M - 1.

2. CrossCorrelate

public static Signal CrossCorrelate(Signal signal1, Signal signal2)
- Uses FFT for fast cross-correlation of signal1 and signal2.
- Parameters:
  - signal1: input signal1.
  - signal2: input signal2.
- Returns: cross-correlation result Signal.
public static ComplexDiscreteSignalFp32 CrossCorrelate(ComplexDiscreteSignalFp32 signal1, ComplexDiscreteSignalFp32 signal2)
- Uses FFT for fast cross-correlation of signal1 and signal2.
- Parameters:
  - signal1: input signal1.
  - signal2: input signal2.
- Returns: ComplexDiscreteSignalFp32 cross-correlation result.
public static float[] CrossCorrelate(float[] signal1, float[] signal2)
public static T[] CrossCorrelate<T>(T[] signal1, T[] signal2, ComputingContext? context = null)
- 0.10.19: FFT cross-correlation in T. Length N + M - 1. Inputs are not mutated.

3. BlockConvolve

public static Signal BlockConvolve(Signal signal, Signal kernel, int fftSize, FilteringMethod method = FilteringMethod.OverlapSave)
- Block-convolves signal and kernel (overlap-add or overlap-save).
- Parameters:
  - signal: input signal.
  - kernel: kernel.
  - fftSize: FFT size.
  - method: block convolution method (OverlapAdd / OverlapSave); default FilteringMethod.OverlapSave..
- Returns: block convolution result Signal.

4. Deconvolve

public static ComplexDiscreteSignalFp32 Deconvolve(ComplexDiscreteSignalFp32 signal, ComplexDiscreteSignalFp32 kernel)
- Deconvolves signal and kernel.
- Parameters:
  - signal: input signal.
  - kernel: kernel.
- Returns: ComplexDiscreteSignalFp32 deconvolution result.

5. Interpolate

public static Signal Interpolate(Signal signal, int factor, FirFilter? filter = null)
- Interpolates signal with low-pass filtering.
- Parameters:
  - signal: input signal.
  - factor: interpolation factor (e.g. factor=2: 8000 Hz -> 16000 Hz)..
  - filter: low-pass anti-aliasing filter..
- Returns: interpolation result Signal.

6. Decimate

public static Signal Decimate(Signal signal, int factor, FirFilter? filter = null)
- Decimates signal with low-pass filtering.
- Parameters:
  - signal: input signal.
  - factor: decimation factor (e.g. factor=2: 16000 Hz -> 8000 Hz)..
  - filter: low-pass anti-aliasing filter..
- Returns: decimation result Signal.

7. Resample

public static Signal Resample(Signal signal, float newSamplingRate, FirFilter? filter = null, int order = 15)
- Band-limited resampling of signal.
- Parameters:
  - signal: input signal.
  - newSamplingRate: target sample rate..
  - filter: low-pass anti-aliasing filter..
  - order: filterorder, default 15.
- Returns: resampling result Signal.
public static Signal ResampleUpDown(Signal signal, int up, int down, FirFilter? filter = null)
- Simple resampling of signal (interpolation + decimation).
- Parameters:
  - signal: input signal.
  - up: interpolation factor..
  - down: decimation factor..
  - filter: low-pass anti-aliasing filter..
- Returns: resampling result Signal.

8. TimeStretch

public static Signal TimeStretch(Signal signal, float stretch, int windowSize, int hopSize, TsmAlgorithm algorithm = TsmAlgorithm.PhaseVocoderPhaseLocking)
- Time-stretches signal with user-specified parameters.
- Parameters:
  - signal: input signal.
  - stretch: stretch factor (ratio)..
  - windowSize: window size (vocoder FFT size)..
  - hopSize: hop length..
  - algorithm: time-stretch algorithm; default TsmAlgorithm.PhaseVocoderPhaseLocking..
- Returns: time-stretch result Signal.
public static Signal TimeStretch(Signal signal, double stretch, TsmAlgorithm algorithm = TsmAlgorithm.PhaseVocoderPhaseLocking)
- Time-stretches signal with auto-derived parameters.
- Parameters:
  - signal: input signal.
  - stretch: stretch factor (ratio)..
  - algorithm: time-stretch algorithm; default TsmAlgorithm.PhaseVocoderPhaseLocking..
- Returns: time-stretch result Signal.

9. Envelope

public static Signal Envelope(Signal signal, float attackTime = 0.01f, float releaseTime = 0.05f)
- Extracts envelope of signal.
- Parameters:
  - signal: input signal.
  - attackTime: attack time (seconds); default 0.01 s..
  - releaseTime: release time (seconds); default 0.05 s..
- Returns: envelope result Signal.

10. FullRectify

public static Signal FullRectify(Signal signal)
- Full-wave rectifies signal.
- Parameters:
  - signal: input signal.
- Returns: full-wave rectification result Signal.

11. HalfRectify

public static Signal HalfRectify(Signal signal)
- Half-wave rectifies signal.
- Parameters:
  - signal: input signal.
- Returns: half-wave rectification result Signal.

12. SpectralSubtract

public static Signal SpectralSubtract(Signal signal, Signal noise, int fftSize = 1024, int hopSize = 256)
- Denoises signal via spectral subtraction; subtracts noise from signal.
- Parameters:
  - signal: input signal.
  - noise: noise signal..
  - fftSize: FFT size; default 1024.
  - hopSize: hop size (sample count), default 256..
- Returns: denoised result Signal.

13. NormalizePeak

public static void NormalizePeak(float[] samples, float peakDb)
- Normalizes peak level.
- Parameters:
  - samples: sample array..
  - peakDb: peak level (dB), e.g. -1 dB, -3 dB..
public static Signal NormalizePeak(Signal signal, float peakDb)
- Normalizes peak level.
- Parameters:
  - signal: input signal.
  - peakDb: peak level (dB), e.g. -1 dB, -3 dB..
- Returns: normalization result Signal.

14. ChangePeak

public static void ChangePeak(float[] samples, float peakDb)
- Changes peak level relative to input samples (in-place).
- Parameters:
  - samples: sample array..
  - peakDb: peak change (dB), e.g. -6 dB halves peak level..
public static Signal ChangePeak(Signal signal, float peakDb)
- Changes peak level relative to input signal.
- Parameters:
  - signal: input signal.
  - peakDb: peak change (dB), e.g. -6 dB halves peak level..
- Returns: peak-adjusted Signal.

15. NormalizeRms

public static void NormalizeRms(float[] samples, float rmsDb)
- Normalizes RMS.
- Parameters:
  - samples: sample array..
  - rmsDb: RMS level (dB), e.g. -6 dB, -18 dB, -26 dB..
public static Signal NormalizeRms(Signal signal, float rmsDb)
- Normalizes RMS.
- Parameters:
  - signal: input signal.
  - rmsDb: RMS level (dB), e.g. -6 dB, -18 dB, -26 dB..
- Returns: normalization result Signal.

16. ChangeRms

public static void ChangeRms(float[] samples, float rmsDb)
- Changes RMS relative to input samples.
- Parameters:
  - samples: sample array..
  - rmsDb: RMS change (dB), e.g. -6 dB halves RMS..
public static Signal ChangeRms(Signal signal, float rmsDb)
- Changes RMS relative to input signal.
- Parameters:
  - signal: input signal.
  - rmsDb: RMS change (dB), e.g. -6 dB halves RMS..
- Returns: RMS-adjusted Signal.

17. Welch

public static float[] Welch(Signal signal, int windowSize = 1024, int hopSize = 256, WindowType window = WindowType.Hann, int fftSize = 0, int samplingRate = 0, ComputingContext? context = null)
- Computes periodogram via Welch method; if samplingRate=0 evaluates power spectrum, else PSD. Averages complete STFT windows only (via Stft.AveragePeriodogram). Optional context for frame-level parallel / SIMD.
- Parameters:
  - signal: input signal.
  - windowSize: window size (samples); default 1024..
  - hopSize: hop size (sample count), default 256..
  - window: window function; default WindowType.Hann..
  - fftSize: FFT size; default 0.
  - samplingRate: if sample rate=0 evaluates power spectrum, else power spectral density..
  - context: optional ComputingContext (0.10.13+).
- Returns: periodogram array.

18. LombScargle

public static float[] LombScargle(float[] x, float[] y, float[] freqs, bool subtractMean = false, bool normalize = false)
- Computes Lomb–Scargle periodogram.
- Parameters:
  - x: sample times..
  - y: signal values at sample times..
  - freqs: angular frequencies for output periodogram..
  - subtractMean: subtract mean from values before evaluating periodogram..
  - normalize: normalize periodogram by residuals around constant reference model (zero)..
- Returns: periodogram array.

Code example

The following example uses Operation with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Operations;
using Vorcyc.Mathematics.SignalProcessing.Signals;

public class OperationExample
{
    public static void Main()
    {
        // Define input signal and kernel
        var signal = Signal.FromCopy(new float[] { 0.5f, 0.6f, 0.55f }, 44100);
        var kernel = Signal.FromCopy(new float[] { 0.3f, 0.4f }, 44100);

        // Run convolution
        var convolvedSignal = Operation.Convolve(signal, kernel);
        Console.WriteLine("Convolved Signal:");
        foreach (var sample in convolvedSignal.Samples)
        {
            Console.WriteLine($"Sample: {sample}");
        }

        // Run cross-correlation
        var crossCorrelatedSignal = Operation.CrossCorrelate(signal, kernel);
        Console.WriteLine("Cross-Correlated Signal:");
        foreach (var sample in crossCorrelatedSignal.Samples)
        {
            Console.WriteLine($"Sample: {sample}");
        }

        // Performstime stretch
        var timeStretchedSignal = Operation.TimeStretch(signal, 1.5f, 1024, 256);
        Console.WriteLine("Time-Stretched Signal:");
        foreach (var sample in timeStretchedSignal.Samples)
        {
            Console.WriteLine($"Sample: {sample}");
        }

        // Extract envelope
        var envelopeSignal = Operation.Envelope(signal);
        Console.WriteLine("Envelope Signal:");
        foreach (var sample in envelopeSignal.Samples)
        {
            Console.WriteLine($"Sample: {sample}");
        }

        // Perform full-wave rectification
        var fullRectifiedSignal = Operation.FullRectify(signal);
        Console.WriteLine("Full-Rectified Signal:");
        foreach (var sample in fullRectifiedSignal.Samples)
        {
            Console.WriteLine($"Sample: {sample}");
        }

        // Perform spectral subtraction denoising
        var noise = Signal.FromCopy(new float[] { 0.1f, 0.1f, 0.1f }, 44100);
        var denoisedSignal = Operation.SpectralSubtract(signal, noise);
        Console.WriteLine("Denoised Signal:");
        foreach (var sample in denoisedSignal.Samples)
        {
            Console.WriteLine($"Sample: {sample}");
        }

        // peak level normalization
        var normalizedPeakSignal = Operation.NormalizePeak(signal, -3);
        Console.WriteLine("Normalized Peak Signal:");
        foreach (var sample in normalizedPeakSignal.Samples)
        {
            Console.WriteLine($"Sample: {sample}");
        }

        // normalized RMS
        var normalizedRmsSignal = Operation.NormalizeRms(signal, -18);
        Console.WriteLine("Normalized RMS Signal:");
        foreach (var sample in normalizedRmsSignal.Samples)
        {
            Console.WriteLine($"Sample: {sample}");
        }

        // Compute Welch periodogram
        var welchPeriodogram = Operation.Welch(signal);
        Console.WriteLine("Welch Periodogram:");
        foreach (var value in welchPeriodogram)
        {
            Console.WriteLine($"Value: {value}");
        }
    }
}

Vorcyc.Mathematics.SignalProcessing.Operations.Resampler class

Vorcyc.Mathematics.SignalProcessing.Operations.Resampler is used for signal resampling (sample-rate conversion).

Properties

1. MinResamplingFilterOrder

public int MinResamplingFilterOrder { get; set; }
- Gets or sets low-pass anti-aliasing FIR filter order; auto-created if not specified. Default 101.

Methods

1. Interpolate

public Signal Interpolate(Signal signal, int factor, FirFilter? filter = null)
- Interpolates signal with low-pass filtering.
- Parameters:
  - signal: input signal.
  - factor: interpolation factor (e.g. factor=2: 8000 Hz -> 16000 Hz)..
  - filter: low-pass anti-aliasing filter..
- Returns: interpolation result Signal.

2. Decimate

public Signal Decimate(Signal signal, int factor, FirFilter? filter = null)
- Decimates signal with low-pass filtering.
- Parameters:
  - signal: input signal.
  - factor: decimation factor (e.g. factor=2: 16000 Hz -> 8000 Hz)..
  - filter: low-pass anti-aliasing filter..
- Returns: decimation result Signal.

3. Resample

public Signal Resample(Signal signal, float newSamplingRate, FirFilter? filter = null, int order = 15)
- Band-limited resampling of signal.
- Parameters:
  - signal: input signal.
  - newSamplingRate: target sample rate..
  - filter: low-pass anti-aliasing filter..
  - order: filterorder, default 15.
- Returns: resampling result Signal.

4. ResampleUpDown

public Signal ResampleUpDown(Signal signal, int up, int down, FirFilter? filter = null)
- Simple resampling of signal (interpolation + decimation).
- Parameters:
  - signal: input signal.
  - up: interpolation factor..
  - down: decimation factor..
  - filter: low-pass anti-aliasing filter..
- Returns: resampling result Signal.

Code example

The following example uses Resampler with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Operations;
using Vorcyc.Mathematics.SignalProcessing.Signals;

public class ResamplerExample
{
    public static void Main()
    {
        // Define input signal
        var signal = Signal.FromCopy(new float[] { 0.5f, 0.6f, 0.55f }, 44100);

        // Create Resampler instance
        var resampler = new Resampler();

        // Perform interpolation
        var interpolatedSignal = resampler.Interpolate(signal, 2);
        Console.WriteLine("Interpolated Signal:");
        foreach (var sample in interpolatedSignal.Samples)
        {
            Console.WriteLine($"Sample: {sample}");
        }

        // Perform decimation
        var decimatedSignal = resampler.Decimate(signal, 2);
        Console.WriteLine("Decimated Signal:");
        foreach (var sample in decimatedSignal.Samples)
        {
            Console.WriteLine($"Sample: {sample}");
        }

        // Perform band-limited resampling
        var resampledSignal = resampler.Resample(signal, 22050);
        Console.WriteLine("Resampled Signal:");
        foreach (var sample in resampledSignal.Samples)
        {
            Console.WriteLine($"Sample: {sample}");
        }

        // Perform simple resampling (interpolation + decimation)
        var resampledUpDownSignal = resampler.ResampleUpDown(signal, 2, 3);
        Console.WriteLine("Resampled UpDown Signal:");
        foreach (var sample in resampledUpDownSignal.Samples)
        {
            Console.WriteLine($"Sample: {sample}");
        }
    }
}

Vorcyc.Mathematics.SignalProcessing.Operations.SpectralSubtractor class

Vorcyc.Mathematics.SignalProcessing.Operations.SpectralSubtractor implements spectral subtraction filtering.

Properties

1. Beta

public float Beta { get; set; }
- Gets or sets spectral floor (beta). Default 0.009f.

2. AlphaMin

public float AlphaMin { get; set; }
- Gets or sets minimum subtraction factor (alpha). Default 2f.

3. AlphaMax

public float AlphaMax { get; set; }
- Gets or sets maximum subtraction factor (alpha). Default 5f.

4. SnrMin

public float SnrMin { get; set; }
- Gets or sets minimum SNR (dB).default -5f.

5. SnrMax

public float SnrMax { get; set; }
- Gets or sets maximum SNR (dB).default 20f.

Methods

1. SpectralSubtractor constructor

public SpectralSubtractor(float[] noise, int fftSize = 1024, int hopSize = 128)
- Constructs SpectralSubtractor with noise sample array, FFT size, and hop length.
- Parameters:
  - noise: noise sample array..
  - fftSize: FFT size; default 1024.
  - hopSize: hop length (samples); default 128..
public SpectralSubtractor(DiscreteSignal noise, int fftSize = 1024, int hopSize = 128)
- Constructs SpectralSubtractor with noise signal, FFT size, and hop length.
- Parameters:
  - noise: noise signal..
  - fftSize: FFT size; default 1024.
  - hopSize: hop length (samples); default 128..

2. ProcessSpectrum

protected override void ProcessSpectrum(float[] re, float[] im, float[] filteredRe, float[] filteredIm)
- Processes one spectrum per STFT step.
- Parameters:
  - re: real part of input spectrum..
  - im: imaginary part of input spectrum..
  - filteredRe: real part of output spectrum..
  - filteredIm: imaginary part of output spectrum..

3. EstimateNoise

public void EstimateNoise(float[] noise, int startPos = 0, int endPos = -1)
- Estimates noise power spectrum.
- Parameters:
  - noise: noise sample array..
  - startPos: index of first sample processed in array..
  - endPos: index of last sample processed in array..
public void EstimateNoise(DiscreteSignal noise, int startPos = 0, int endPos = -1)
- Estimates noise signal power spectrum.
- Parameters:
  - noise: noise signal..
  - startPos: index of first sample processed in signal..
  - endPos: index of last sample processed in signal..

Code example

The following example uses SpectralSubtractor with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Operations;

public class SpectralSubtractorExample
{
    public static void Main()
    {
        // Define noise sample array
        float[] noiseSamples = { 0.1f, 0.1f, 0.1f, 0.1f, 0.1f };

        // Create SpectralSubtractor instance
        var subtractor = new SpectralSubtractor(noiseSamples);

        // Define input signal
        float[] inputSignal = { 0.5f, 0.6f, 0.55f, 0.7f, 0.65f, 0.8f, 0.75f, 0.9f };
        var signal = new DiscreteSignal(44100, inputSignal);

        // Perform spectral subtraction denoising
        var denoisedSignal = subtractor.ApplyTo(signal);
        Console.WriteLine("Denoised Signal:");
        foreach (var sample in denoisedSignal.Samples)
        {
            Console.WriteLine($"Sample: {sample}");
        }
    }
}

Vorcyc.Mathematics.SignalProcessing.Operations.WaveShaper class

Vorcyc.Mathematics.SignalProcessing.Operations.WaveShaper is used for waveshaping.

Properties

None

Methods

1. WaveShaper constructor

public WaveShaper(Func<float, float> waveShapingFunction)
- Constructs WaveShaper with waveshaping function.
- Parameters:
  - waveShapingFunction: waveshaping function..

2. Process

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

3. Reset

public void Reset()
- Resets waveshaper.

4. ApplyTo

public Signal ApplyTo(Signal signal, FilteringMethod method = FilteringMethod.Auto)
- Processes entire signal and returns waveshaped signal.
- Parameters:
  - signal: input signal.
  - method: filtering method, default FilteringMethod.Auto..
- Returns: processed Signal.

Code example

The following example uses WaveShaper with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Operations;
using Vorcyc.Mathematics.SignalProcessing.Signals;

public class WaveShaperExample
{
    public static void Main()
    {
        // Define waveshaping function
        Func<float, float> waveShapingFunction = x => x * x;

        // Create WaveShaper instance
        var waveShaper = new WaveShaper(waveShapingFunction);

        // Define input signal
        float[] inputSignal = { 0.5f, 0.6f, 0.55f, 0.7f, 0.65f, 0.8f, 0.75f, 0.9f };
        var signal = Signal.FromCopy(inputSignal, 44100);

        // Process entire signal
        var outputSignal = waveShaper.ApplyTo(signal);
        Console.WriteLine("Wave-Shaped Signal:");
        foreach (var sample in outputSignal.Samples)
        {
            Console.WriteLine($"Sample: {sample}");
        }

        // Process single sample
        float processedSample = waveShaper.Process(0.85f);
        Console.WriteLine($"Processed Sample: {processedSample}");

        // Reset waveshaper
        waveShaper.Reset();
    }
}

Time-scale modification (`Operations.Tsm`)

Namespace: Vorcyc.Mathematics.SignalProcessing.Operations.Tsm

Used by Operation.TimeStretch, PitchShiftEffect, and related APIs.

`TsmAlgorithm` enum

Value	Algorithm
`PhaseVocoder`	Classic phase vocoder
`PhaseVocoderPhaseLocking`	Phase vocoder with phase locking (default)
`Wsola`	Waveform similarity overlap-add
`PaulStretch`	Paul stretch

Filter implementations

Type	Description
`PhaseVocoder`	`IFilter` phase-vocoder TSM
`PhaseLockingVocoder`	Phase-locked variant
`Wsola`	WSOLA time-stretch filter

Operation.TimeStretch(Signal, ...) overloads accept TsmAlgorithm (prefer Signal).

Language / 语言: English · 简体中文

Home

📒 GPU policy
- 🔖 Why the main package drops GPU
- 🔖 Current performance path
- 🔖 If you still need more compute
📒 ComputingContext module
- 🔖 ComputingContext / ComputingScope
- 🔖 Integrated APIs
- 🔖 Verification and tests
- 🔖 FftVersion (removed)
- 🔖 ComputingBackend / priority
📒 Core module
- 🔖 ArrayExtension class
- 🔖 BaseConverter class
- 🔖 BitMathExtension class
- 🔖 Combinatorics class
- 🔖 ConstantsFp32 class
- 🔖 NumberMapper class
- 🔖 PinnableArray<T> class
- 🔖 SimpleRNG_Fp32 and SimpleRNG_Fp64 classes
- 🔖 TrigonometryHelper class
- 🔖 VMath class
- 🔖 Pinned buffers (Buffers)
- 🔖 IPinnedBuffer<T> interface
- 🔖 POHBuffer<T> class
- 🔖 NativeBuffer<T> class
📒 Deep learning module
- 🔖 BatchTensor and Trainer
- 🔖 Learning-rate schedulers
- 🔖 ModelSerializer v3
- 🔖 Audio integration
- 🔖 Layers.Layers class (legacy)
📒 Linear algebra module
- 🔖 BasisTransformation class
- 🔖 LinearEquationSolver class
- 🔖 Matrix class
- 🔖 Matrix<T> class
- 🔖 VMatrixHelper class
- 🔖 MatrixOperations class
- 🔖 Quaternion struct
- 🔖 Tensor class
- 🔖 Tensor<T> class
- 🔖 VectorSpan class
📒 Machine learning module
- 🔖 0.9 classifier walkthrough
- 🔖 KNN<T> class
- 🔖 MultipleLinearRegression<T> class
- 🔖 SimpleLinearRegression<T> class
- 🔖 SupportVectorMachine<TSelf> class
- 🔖 DBSCAN<T> class
- 🔖 ExpectationMaximization<T> class
- 🔖 GMM<T> class
- 🔖 HierarchicalClustering<T> class
- 🔖 KMeansClusterer<T> class
- 🔖 VectorQuantization<T> class
- 🔖 FactorAnalysis<T> class
- 🔖 PCA<TSelf> class
- 🔖 TSNE<T> class
- 🔖 Distance metric classes
📒 Signal processing module
- 🔖 Audio effects
- 🔖 Feature extractors
- 🔖 Other audio feature computation
- 🔖 Filters
- 🔖 Fourier transforms
- 🔖 Common operations
- 🔖 Time-scale modification (Tsm)
- 🔖 Signal definition and related operations
- 🔖 Generators (0.9+)
- 🔖 Transform operations
- 🔖 Window functions
- 🔖 Other
📒 Numerics module
- 🔖 BigFloat struct
- 🔖 Complex<T> struct
- 🔖 ComplexFp32 struct
- 🔖 Int24 struct
- 🔖 IntRange struct
- 🔖 Number class
- 🔖 Point<T> struct
- 🔖 PointFp32 struct
- 🔖 Range<T> class
- 🔖 Rational<T> struct
- 🔖 RectangleFP32 struct
- 🔖 Size<T> struct
- 🔖 SizeFp32 struct
- 🔖 UInt24 struct
📒 Statistics module
- 🔖 Basic statistics functions
- 🔖 Advanced statistics functions
- 🔖 Robust / RunningMoments
- 🔖 Other statistics functions
- 🔖 Distribution functions
- 🔖 Time series analysis
- 🔖 IComparable extensions
- 🔖 ExtremeValueFinder
- 🔖 INumber extensions
📒Calculus module
- 🔖 Limits class
- 🔖 Integration class
- 🔖 Derivative class
- 🔖 TaylorSeries class
- 🔖 FourierSeries class
- 🔖 RungeKutta class
- 🔖 NewtonRaphson class
- 🔖 Performance tuning guide
📒 FFTW extension
- 🔖 Single-precision DFT
- 🔖 Dft1D — 1D transform
- 🔖 Dft2D — 2D transform
- 🔖 Dft3D — 3D transform
- 🔖 DftND — N-D transform
- 🔖 RealToRealTransforms
- 🔖 Double-precision DFT
- 🔖 HilbertTransform class
- 🔖 EnvelopeComputer class
- 🔖 SignalExtension class
📒 Examples
- 🔖 Directory structure conventions
- 🔖 Audio_example — NAudio audio pipeline
- 🔖 Core_example — core and ComputingContext
- 🔖 MachineLearning_example — tabular learning
- 🔖 Colorization_example — image colorization
- 🔖 Models and scenarios
- 🔖 Command-line usage
- 🔖 Relationship to the deep learning module

首页

📒 GPU 策略说明
- 🔖 为何放弃主包 GPU
- 🔖 当前性能路径
- 🔖 若仍需要更强算力
📒 计算上下文模块
- 🔖 ComputingContext / ComputingScope
- 🔖 已接入 API
- 🔖 验证与测试
- 🔖 FftVersion（已删除）
- 🔖 ComputingBackend / 优先级
📒 核心模块
- 🔖 ArrayExtension 类
- 🔖 BaseConverter 类
- 🔖 BitMathExtension 类
- 🔖 Combinatorics 类
- 🔖 ConstantsFp32 类
- 🔖 NumberMapper 类
- 🔖 PinnableArray<T> 类
- 🔖 SimpleRNG_Fp32 和 SimpleRNG_Fp64 类
- 🔖 TrigonometryHelper 类
- 🔖 VMath 类
- 🔖 固定缓冲区（Buffers）
- 🔖 IPinnedBuffer<T> 接口
- 🔖 POHBuffer<T> 类
- 🔖 NativeBuffer<T> 类
📒 深度学习模块
- 🔖 BatchTensor 与 Trainer
- 🔖 学习率调度器
- 🔖 ModelSerializer v3
- 🔖 音频集成
- 🔖 Layers.Layers 类（遗留）
📒 线性代数模块
- 🔖 BasisTransformation 类
- 🔖 LinearEquationSolver 类
- 🔖 Matrix 类
- 🔖 Matrix<T> 类
- 🔖 VMatrixHelper 类
- 🔖 MatrixOperations 类
- 🔖 Quaternion 结构
- 🔖 Tensor 类
- 🔖 Tensor<T> 类
- 🔖 VectorSpan 类
📒 机器学习模块
- 🔖 0.9 分类器完整示例
- 🔖 KNN<T> 类
- 🔖 MultipleLinearRegression<T> 类
- 🔖 SimpleLinearRegression<T> 类
- 🔖 SupportVectorMachine<TSelf> 类
- 🔖 DBSCAN<T> 类
- 🔖 ExpectationMaximization<T> 类
- 🔖 GMM<T> 类
- 🔖 HierarchicalClustering<T> 类
- 🔖 KMeansClusterer<T> 类
- 🔖 VectorQuantization<T> 类
- 🔖 FactorAnalysis<T> 类
- 🔖 PCA<TSelf> 类
- 🔖 TSNE<T> 类
- 🔖 距离度量类
📒 信号处理模块
- 🔖 音效处理
- 🔖 特征提取器
- 🔖 其他音频特征计算
- 🔖 滤波器
- 🔖 傅立叶变换
- 🔖 常用操作
- 🔖 时标变换（Tsm）
- 🔖 信号定义和相关操作
- 🔖 Generators（0.9+）
- 🔖 变换操作
- 🔖 窗函数
- 🔖 其它
📒 数值模块
- 🔖 BigFloat 结构体
- 🔖 Complex<T> 结构体
- 🔖 ComplexFp32 结构体
- 🔖 Int24 结构体
- 🔖 IntRange 结构体
- 🔖 Number 类
- 🔖 Point<T> 结构体
- 🔖 PointFp32 结构体
- 🔖 Range<T> 类
- 🔖 Rational<T> 结构体
- 🔖 RectangleFP32 结构体
- 🔖 Size<T> 结构体
- 🔖 SizeFp32 结构体
- 🔖 UInt24 结构体
📒 统计模块
- 🔖 基础统计函数
- 🔖 高级统计函数
- 🔖 稳健统计 / RunningMoments
- 🔖 其它统计函数
- 🔖 分布相关函数
- 🔖 时间序列分析
- 🔖 IComparable 扩展
- 🔖 ExtremeValueFinder
- 🔖 INumber 扩展
📒微积分模块
- 🔖 Limits 类
- 🔖 Integration 类
- 🔖 Derivative 类
- 🔖 TaylorSeries 类
- 🔖 FourierSeries 类
- 🔖 RungeKutta 类
- 🔖 NewtonRaphson 类
- 🔖 性能调优指南
📒 FFTW 扩展
- 🔖 单精度 DFT
- 🔖 Dft1D — 一维变换
- 🔖 Dft2D — 二维变换
- 🔖 Dft3D — 三维变换
- 🔖 DftND — N 维变换
- 🔖 RealToRealTransforms
- 🔖 双精度 DFT
- 🔖 HilbertTransform 类
- 🔖 EnvelopeComputer 类
- 🔖 SignalExtension 类
📒 示例
- 🔖 目录结构约定
- 🔖 Audio_example — NAudio 音频流水线
- 🔖 Core_example — 核心与 ComputingContext
- 🔖 MachineLearning_example — 表格学习
- 🔖 Colorization_example — 图像上色
- 🔖 模型与场景
- 🔖 命令行用法
- 🔖 与深度学习模块的关系

Module_SignalProcessing_Operations

Signal Processing Module

Operations

Vorcyc.Mathematics.SignalProcessing.Operations.Convolution.ComplexConvolver class

Methods

1. Convolve

2. CrossCorrelate

3. Deconvolve

Code example

Vorcyc.Mathematics.SignalProcessing.Operations.Convolution.Convolver class

Methods

1. Convolve

2. CrossCorrelate

Code example

Vorcyc.Mathematics.SignalProcessing.Operations.Convolution.Convolver<T> / Convolver64

Vorcyc.Mathematics.SignalProcessing.Operations.Convolution.OlaBlockConvolver class

Properties

1. HopSize

Methods

1. OlaBlockConvolver constructor

2. ChangeKernel

3. Process

4. ApplyTo

5. Reset

Code example

Vorcyc.Mathematics.SignalProcessing.Operations.Convolution.OlsBlockConvolver class

Properties

1. HopSize

Methods

1. OlsBlockConvolver constructor

2. ChangeKernel

3. Process

4. ApplyTo

5. Reset

Code example

Vorcyc.Mathematics.SignalProcessing.Operations.DynamicsMode enum

Enum members

1. Compressor

2. Limiter

3. Expander

4. NoiseGate

Vorcyc.Mathematics.SignalProcessing.Operations.DynamicsProcessor class

Properties

1. Threshold

2. Ratio

3. MakeupGain

4. Attack

5. Release

Methods

1. DynamicsProcessor constructor

2. Process

3. Reset

4. ApplyTo

Code example

Vorcyc.Mathematics.SignalProcessing.Operations.EnvelopeFollower class

Properties

1. AttackTime

2. ReleaseTime

Methods

1. EnvelopeFollower constructor

2. Process

3. Reset

4. ApplyTo

Code example

Vorcyc.Mathematics.SignalProcessing.Operations.GriffinLimReconstructor class

Properties

1. Gain

Methods

1. GriffinLimReconstructor constructor

2. Iterate

3. Reconstruct

Code example

Vorcyc.Mathematics.SignalProcessing.Operations.HarmonicPercussiveSeparator class

Methods

1. HarmonicPercussiveSeparator constructor

2. EvaluateSpectrograms

3. EvaluateSignals

Code example

Vorcyc.Mathematics.SignalProcessing.Operations.Modulator class

Methods

Time-scale modification (`Operations.Tsm`)

`TsmAlgorithm` enum