Module_SignalProcessing_Signals

Location: Home / Signal processing / Signals

Signal Processing Module

Signals

The Vorcyc.Mathematics.SignalProcessing.Signals namespace provides time-domain and frequency-domain signal definitions and editing utilities.

0.9 recommended API

Type	Description
`Signal`	Primary single-threaded real time-domain type: `float` sample rate, pinned buffer, `Samples` as `Span<float>`, implements `ISingleThreadTimeDomainSignal`
`SignalSegment`	Zero-copy slice `signal[start, length]` of parent `Signal`; frame-level SIMD statistics and features
`SignalExtensions`	Signal editing and frame statistics extensions (replaces obsolete `DiscreteSignalExtensions`)
`ComplexDiscreteSignalFp32`	Complex discrete signal (convolution, frequency-domain ops, etc.)
`Signals.Generators.*`	0.9+ sample-by-sample generators (`ISampleGenerator`) and offline `ToSignal` / `Fill` helpers

Compatibility / obsolete

DiscreteSignal, DiscreteSignalExtensions: still available, marked [Obsolete]; use Signal / SignalExtensions or DiscreteSignal.ToSignal().
The legacy Signals.Builders.* types have been removed; use Generators instead (see migration table).
The DiscreteSignal sections below are kept for migration reference; new code should use the Signal class.

Generators (0.9+)

Namespace: Vorcyc.Mathematics.SignalProcessing.Signals.Generators

Streaming / offline waveform synthesis. ISampleGenerator.NextSample() drives per-sample generation; SampleGeneratorExtensions fills a Signal or builds one via ToSignal(length, samplingRate).

Type	Description
`ISampleGenerator`	`NextSample()`, `Reset()`
`IAmplitudeOscillator`	Oscillator with `Frequency`, `Min`, `Max` (extends `ISampleGenerator`)
`SampleGeneratorExtensions`	`Fill(generator, signal)`, `ToSignal(...)`, `SetLfoFrequency`, `SetLfoRange`
`SineOscillator` / `CosineOscillator`	Basic periodic waves
`SquareOscillator` / `SawtoothOscillator` / `TriangleOscillator`	Periodic waves
`ChirpOscillator`	Frequency sweep
`SincGenerator` / `RampGenerator`	Sinc pulse, linear ramp
`AwgnGenerator` / `WhiteNoiseGenerator` / `PinkNoiseGenerator` / `RedNoiseGenerator` / `PerlinNoiseGenerator`	Noise sources
`PulseWaveGenerator`	Pulse train
`FadeInOutGenerator`	Fade envelope wrapper
`AdsrEnvelope` / `AdsrState`	ADSR envelope (`IAmplitudeOscillator`)
`WaveTableGenerator`	Wavetable playback base
`KarplusStrongGenerator` / `KarplusStrongDrumGenerator`	Karplus–Strong string / drum
`PadSynthGenerator`	Pad synthesis

Builders → Generators migration (approximate)

Legacy `Builders.*`	Use instead
`SineBuilder`	`SineOscillator` + `ToSignal`
`ChirpBuilder`	`ChirpOscillator`
`AdsrBuilder`	`AdsrEnvelope`
`WhiteNoiseBuilder` / `PinkNoiseBuilder` / …	matching `*NoiseGenerator`
`KarplusStrongBuilder`	`KarplusStrongGenerator`

Example:

using Vorcyc.Mathematics.SignalProcessing.Signals;
using Vorcyc.Mathematics.SignalProcessing.Signals.Generators;

var gen = new SineOscillator(frequency: 440f, samplingRate: 48_000f);
Signal tone = gen.ToSignal(length: 48_000, samplingRate: 48_000f);

`WaveShape` / `GenerateWave`

For one-shot fill of an existing Signal / DiscreteSignal, use GenerateWave(WaveShape, frequency, Behaviour) (extension on ITimeDomainSignal). Shapes map onto the generators above:

`WaveShape`	Notes
`Sine` / `Cosine` / `Square` / `Sawtooth` / `Triangle`	Periodic waves; `frequency` in Hz
`WhiteNoise` / `PinkNoise` / `RedNoise` / `Awgn`	Noise; `frequency` ignored (AWGN uses fixed default σ). 0.10.14: `PinkNoise` uses Paul Kellet `PinkNoiseGenerator` (~±1; prior custom IIR removed)
`Chirp`	Linear chirp; `frequency` is start Hz (end defaults to `min(f×10, 0.45×Nyquist)`)
`Pulse`	Pulse train at `frequency` Hz, 50% duty
`Ramp`	Linear ramp −1…+1 over the buffer; `frequency` ignored
`Sinc`	Scaled sinc; `frequency` sets width (same as `SincGenerator.Frequency`)

var chirp = new Signal(48_000, 48_000f);
chirp.GenerateWave(WaveShape.Chirp, frequency: 100f);

Namespace Vorcyc.Mathematics.SignalProcessing.Signals (types below)

📒 Contents

🔖 Generators (0.9+)
🔖 Vorcyc.Mathematics.SignalProcessing.Signals.Signal class
🔖 Vorcyc.Mathematics.SignalProcessing.Signals.SignalSegment struct
🔖 Vorcyc.Mathematics.SignalProcessing.Signals.SignalExtensions class
🔖 Vorcyc.Mathematics.SignalProcessing.Signals.ComplexDiscreteSignalFp32 class
🔖 Vorcyc.Mathematics.SignalProcessing.Signals.ComplexDiscreteSignal class
🔖 Vorcyc.Mathematics.SignalProcessing.Signals.ComplexDiscreteSignalExtensions class
🔖 Vorcyc.Mathematics.SignalProcessing.Signals.DiscreteSignal class
🔖 Vorcyc.Mathematics.SignalProcessing.Signals.DiscreteSignal class
🔖 Vorcyc.Mathematics.SignalProcessing.Signals.DiscreteSignalExtensions class(obsolete)

Vorcyc.Mathematics.SignalProcessing.Signals.Signal class

Signal is the recommended single-threaded real time-domain type from 0.9. Samples live in POHBuffer<float> and are exposed as Span<float> via Samples; call NotifySamplesModified() after edits to invalidate cached time-domain features.

Constructors and factories

Member	Description
`Signal(int sampleCount, float samplingRate)`	Allocate buffer by sample count and rate
`Signal(TimeSpan duration, float samplingRate)`	Allocate buffer by duration and rate
`Signal.Unit(int length, float samplingRate)`	Unit impulse (first sample is 1)
`Signal.Constant(float value, int length, float samplingRate)`	Constant signal
`Signal.FromCopy(ReadOnlySpan<float>, float)`	Construct from span copy
`Signal.FromCopy(float[], float)`	Construct from array copy

Main properties

Length、SamplingRate（float）、Duration
Samples: read/write Span<float> view
Time-domain features (SIMD-cached): Amplitude, TotalPower, AveragePower, TotalEnergy, AverageEnergy, Rms, ZeroCrossingRate, Entropy

Slicing and copying

this[int start, int length] → zero-copy SignalSegment?
this[Range range]、this[TimeSpan start, TimeSpan duration]
Clone()、CloneRange(int start, int length)

Frequency domain and resampling

TransformToFrequencyDomain(ComputingContext?, WindowType?) → FrequencyDomain (recommended; uses the SoA FftButterflyFp32 kernel when SIMD/parallel is beneficial)
FrequencyDomain.IndexToFrequency: from 0.10.15, maps bins with TransformLength (FFT size); onesided magnitude bins 0…N/2 are always non-negative bin·Δf (do not use unpadded ActualLength)
ISingleThreadTimeDomainSignal.GetRms(context) and other time-domain features (optional execution policy)
Resample(float destinationSamplingRate, FirFilter?, int order) → new Signal

Operators

+, -, *, / (scalar and same-shape Signal element-wise ops; returns new Signal)

Code example

using Vorcyc.Mathematics.SignalProcessing.Signals;

var signal = new Signal(1024, 8000f);
signal.GenerateWave(WaveShape.Sine, 440f);

var frame = signal[256, 512, throwException: true]!.Value;
Console.WriteLine($"Frame RMS: {frame.Rms}");

var copy = signal.CloneRange(0, 256);

Vorcyc.Mathematics.SignalProcessing.Signals.SignalSegment struct

Readonly struct: zero-copy view of contiguous samples on a parent Signal. Implements ITimeDomainSignal / ISingleThreadTimeDomainSignal; frame-level Rms, AverageEnergy, ZeroCrossingRate, Entropy, etc. are lazily computed with SIMD.

Obtained via signal[start, length] or signal[range]
Samples is a Span<float> into the parent buffer sub-range
Can call TransformToFrequencyDomain, Resample independently

Vorcyc.Mathematics.SignalProcessing.Signals.SignalExtensions class

Static extensions migrated from DiscreteSignalExtensions (use this class in new code).

Method	Description
`First` / `Last`	First/last n samples (new `Signal`)
`Amplify` / `Attenuate` / `Reverse`	In-place gain / reverse
`NormalizeMax`	Peak-normalize to [-1, 1]
`Delay`	Delayed copy (positive delay pads; negative delay truncates/shifts left)
`Concatenate` / `Repeat`	Concatenate / repeat
`Superimpose` / `SuperimposeMany` / `Subtract`	Superimpose and subtract (unequal-length broadcast)
`FullRectify` / `HalfRectify`	In-place rectification
`FadeIn` / `FadeOut` / `FadeInFadeOut`	Linear fade in/out (`double` seconds or `TimeSpan`)
`Crossfade`	Crossfade two signals
`ToComplex`	Convert to `ComplexDiscreteSignalFp32` (zero imaginary part)
`Energy` / `Rms` / `ZeroCrossingRate` / `Entropy`	Range statistics (`Signal` or `ReadOnlySpan<float>`)

var a = Signal.Constant(1f, 100, 8000f);
var b = Signal.Constant(0.5f, 100, 8000f);
var mixed = a.Superimpose(b);
a.FadeIn(0.01);
a.FadeOut(0.01);
var joined = a.Crossfade(b, 0.005);

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

Vorcyc.Mathematics.SignalProcessing.Signals.ComplexDiscreteSignalFp32 class

Vorcyc.Mathematics.SignalProcessing.Signals.ComplexDiscreteSignalFp32 represents a finite complex discrete-time signal stored as real and imaginary arrays at a given sample rate.

Properties

1. SamplingRate

public int SamplingRate { get; }
- Gets sample rate (samples per second).

2. Real

public float[] Real { get; }
- Gets real part of complex sample.

3. Imag

public float[] Imag { get; }
- Gets imaginary part of complex sample.

4. Length

public int Length => Real.Length
- Gets signal length.

5. Magnitude

public float[] Magnitude
- Gets magnitude of complex sample.

6. Power

public float[] Power
- Gets power of complex sample (amplitude squared).

7. Phase

public float[] Phase
- Gets phase of complex sample.

8. PhaseUnwrapped

public float[] PhaseUnwrapped
- Gets unwrapped phase of complex sample.

Methods

1. ComplexDiscreteSignalFp32 constructor

public ComplexDiscreteSignalFp32(int samplingRate, float[] real, float[] imag = null, bool allocateNew = false)
- Constructs from real and imaginary arrays ComplexDiscreteSignalFp32 instance.
- Parameters:
  - samplingRate: signal sample rate..
  - real: real-part array of complex signal..
  - imag: imaginary-part array of complex signal; default null..
  - allocateNew: if new memory should be allocated for data, set to true; default false..
public ComplexDiscreteSignalFp32(int samplingRate, IEnumerable<float> real, IEnumerable<float> imag = null)
- Constructs from real and imaginary sets ComplexDiscreteSignalFp32 instance.
- Parameters:
  - samplingRate: signal sample rate..
  - real: real-part set of complex signal..
  - imag: imaginary-part set of complex signal; default null..
public ComplexDiscreteSignalFp32(int samplingRate, IEnumerable<ComplexFp32> samples)
- Constructs from complex sample set ComplexDiscreteSignalFp32 instance.
- Parameters:
  - samplingRate: signal sample rate..
  - samples: complex sample set..
public ComplexDiscreteSignalFp32(int samplingRate, int length, float real = 0.0f, float imag = 0.0f)
- Constructssignal with specified length filled with specified value.
- Parameters:
  - samplingRate: signal sample rate..
  - length: sample count.
  - real: real part value per sample; default 0.0..
  - imag: imaginary part value per sample; default 0.0..
public ComplexDiscreteSignalFp32(int samplingRate, IEnumerable<int> samples, float normalizeFactor = 1.0f)
- constructs signal from integer sample set and normalizes at given sample rate.
- Parameters:
  - samplingRate: signal sample rate..
  - samples: integer sample set..
  - normalizeFactor: each sample is divided by this value; default 1.0..

2. Copy

public ComplexDiscreteSignalFp32 Copy()
- Creates a deep copy of the signal.
- Returns: deep copy of the signal.

3.. Indexers

public float this[int index] { get; set; }
- Sample indexer; applies to real-part array only; use with care.
- Parameters:
  - index: sample index..
- Returns: real part value of sample.
public ComplexDiscreteSignalFp32 this[int startPos, int endPos] { get; }
- Creates a slice of the signal.
- Parameters:
  - startPos: index of first sample (inclusive)..
  - endPos: index of last sample (exclusive)..
- Returns: slice of the signal.

Operator overloads

1. operator +

public static ComplexDiscreteSignalFp32 operator +(ComplexDiscreteSignalFp32 s1, ComplexDiscreteSignalFp32 s2)
- creates new signal by superimposing s1 and s2; if sizes differ, smaller signal is broadcast to match larger.
- Parameters:
  - s1: first signal..
  - s2: second signal..
- Returns: new superimposed signal.
public static ComplexDiscreteSignalFp32 operator +(ComplexDiscreteSignalFp32 s, float constant)
- creates new signal by adding constant to signal s.
- Parameters:
  - s: signal.
  - constant: constant to add to each sample..
- Returns: new signal after adding constant.

2. operator -

public static ComplexDiscreteSignalFp32 operator -(ComplexDiscreteSignalFp32 s, float constant)
- creates new signal by subtracting constant from signal s.
- Parameters:
  - s: signal.
  - constant: constant to subtract from each sample..
- Returns: new signal after subtracting constant.

3. operator *

public static ComplexDiscreteSignalFp32 operator *(ComplexDiscreteSignalFp32 s, float coeff)
- creates new signal by multiplying signal s by coefficient (amplify/attenuate).
- Parameters:
  - s: signal.
  - coeff: amplify/attenuate coefficient..
- Returns: new signal after multiplying by coefficient.

Code example

The following example uses ComplexDiscreteSignalFp32 with comments:

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

public class ComplexDiscreteSignalExample
{
    public static void Main()
    {
        // Define sample rate
        int samplingRate = 44100;

        // Define real and imaginary arrays
        float[] real = { 0.5f, 0.6f, 0.55f };
        float[] imag = { 0.1f, 0.2f, 0.15f };

        // Create ComplexDiscreteSignalFp32 instance
        var signal = new ComplexDiscreteSignalFp32(samplingRate, real, imag);

        // Print signal real and imaginary parts
        Console.WriteLine("Real Parts:");
        foreach (var r in signal.Real)
        {
            Console.WriteLine(r);
        }

        Console.WriteLine("Imaginary Parts:");
        foreach (var i in signal.Imag)
        {
            Console.WriteLine(i);
        }

        // Get and print signal magnitude
        var magnitude = signal.Magnitude;
        Console.WriteLine("Magnitude:");
        foreach (var m in magnitude)
        {
            Console.WriteLine(m);
        }

        // Get and print signal phase
        var phase = signal.Phase;
        Console.WriteLine("Phase:");
        foreach (var p in phase)
        {
            Console.WriteLine(p);
        }

        // Creates a slice of the signal
        var slicedSignal = signal[1, 3];
        Console.WriteLine("Sliced Signal Real Parts:");
        foreach (var r in slicedSignal.Real)
        {
            Console.WriteLine(r);
        }

        // Creates a deep copy of the signal
        var copiedSignal = signal.Copy();
        Console.WriteLine("Copied Signal Real Parts:");
        foreach (var r in copiedSignal.Real)
        {
            Console.WriteLine(r);
        }
    }
}

Vorcyc.Mathematics.SignalProcessing.Signals.ComplexDiscreteSignalFp32<T> class

Vorcyc.Mathematics.SignalProcessing.Signals.ComplexDiscreteSignal<T> represents a finite complex discrete-time signal stored as real and imaginary arrays at a given sample rate.

Properties

1. SamplingRate

public int SamplingRate { get; }
- Gets sample rate (samples per second).

2. Real

public T[] Real { get; }
- Gets real part of complex sample.

3. Imag

public T[] Imag { get; }
- Gets imaginary part of complex sample.

4. Length

public int Length => Real.Length
- Gets signal length.

5. Magnitude

public T[] Magnitude
- Gets magnitude of complex sample.

6. Power

public T[] Power
- Gets power of complex sample (amplitude squared).

7. Phase

public T[] Phase
- Gets phase of complex sample.

8. PhaseUnwrapped

public T[] PhaseUnwrapped
- Gets unwrapped phase of complex sample.

Methods

1. ComplexDiscreteSignalFp32 constructor

public ComplexDiscreteSignalFp32(int samplingRate, T[] real, T[]? imag = null, bool allocateNew = false)
- Constructs from real and imaginary arrays ComplexDiscreteSignalFp32 instance.
- Parameters:
  - samplingRate: signal sample rate..
  - real: real-part array of complex signal..
  - imag: imaginary-part array of complex signal; default null..
  - allocateNew: if new memory should be allocated for data, set to true; default false..
public ComplexDiscreteSignalFp32(int samplingRate, IEnumerable<T> real, IEnumerable<T>? imag = null)
- Constructs from real and imaginary sets ComplexDiscreteSignalFp32 instance.
- Parameters:
  - samplingRate: signal sample rate..
  - real: real-part set of complex signal..
  - imag: imaginary-part set of complex signal; default null..
public ComplexDiscreteSignalFp32(int samplingRate, IEnumerable<Complex<T>> samples)
- Constructs from complex sample set ComplexDiscreteSignalFp32 instance.
- Parameters:
  - samplingRate: signal sample rate..
  - samples: complex sample set..
public ComplexDiscreteSignalFp32(int samplingRate, int length, T real = default, T imag = default)
- Constructssignal with specified length filled with specified value.
- Parameters:
  - samplingRate: signal sample rate..
  - length: sample count.
  - real: real part value per sample; default 0.0..
  - imag: imaginary part value per sample; default 0.0..
public ComplexDiscreteSignalFp32(int samplingRate, IEnumerable<T> samples, T? normalizeFactor = null)
- constructs signal from integer sample set and normalizes at given sample rate.
- Parameters:
  - samplingRate: signal sample rate..
  - samples: integer sample set..
  - normalizeFactor: each sample is divided by this value; default 1.0..

2. Copy

public ComplexDiscreteSignal<T> Copy()
- Creates a deep copy of the signal.
- Returns: deep copy of the signal.

3.. Indexers

public T this[int index] { get; set; }
- Sample indexer; applies to real-part array only; use with care.
- Parameters:
  - index: sample index..
- Returns: real part value of sample.
public ComplexDiscreteSignal<T> this[int startPos, int endPos] { get; }
- Creates a slice of the signal.
- Parameters:
  - startPos: index of first sample (inclusive)..
  - endPos: index of last sample (exclusive)..
- Returns: slice of the signal.

Operator overloads

1. operator +

public static ComplexDiscreteSignal<T> operator +(ComplexDiscreteSignal<T> s1, ComplexDiscreteSignal<T> s2)
- creates new signal by superimposing s1 and s2; if sizes differ, smaller signal is broadcast to match larger.
- Parameters:
  - s1: first signal..
  - s2: second signal..
- Returns: new superimposed signal.
public static ComplexDiscreteSignal<T> operator +(ComplexDiscreteSignal<T> s, T constant)
- creates new signal by adding constant to signal s.
- Parameters:
  - s: signal.
  - constant: constant to add to each sample..
- Returns: new signal after adding constant.

2. operator -

public static ComplexDiscreteSignal<T> operator -(ComplexDiscreteSignal<T> s, T constant)
- creates new signal by subtracting constant from signal s.
- Parameters:
  - s: signal.
  - constant: constant to subtract from each sample..
- Returns: new signal after subtracting constant.

3. operator *

public static ComplexDiscreteSignal<T> operator *(ComplexDiscreteSignal<T> s, T coeff)
- creates new signal by multiplying signal s by coefficient (amplify/attenuate).
- Parameters:
  - s: signal.
  - coeff: amplify/attenuate coefficient..
- Returns: new signal after multiplying by coefficient.

Code example

The following example uses ComplexDiscreteSignal<T> with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Signals;
public class ComplexDiscreteSignalExample
{
    public static void Main()
    {
        // Define sample rate
        int samplingRate = 44100;

        // Define real and imaginary arrays
        float[] real = { 0.5f, 0.6f, 0.55f };
        float[] imag = { 0.1f, 0.2f, 0.15f };

        // Create ComplexDiscreteSignalFp32 instance
        var signal = new ComplexDiscreteSignal<float>(samplingRate, real, imag);

        // Print signal real and imaginary parts
        Console.WriteLine("Real Parts:");
        foreach (var r in signal.Real)
        {
            Console.WriteLine(r);
        }

        Console.WriteLine("Imaginary Parts:");
        foreach (var i in signal.Imag)
        {
            Console.WriteLine(i);
        }

        // Get and print signal magnitude
        var magnitude = signal.Magnitude;
        Console.WriteLine("Magnitude:");
        foreach (var m in magnitude)
        {
            Console.WriteLine(m);
        }

        // Get and print signal phase
        var phase = signal.Phase;
        Console.WriteLine("Phase:");
        foreach (var p in phase)
        {
            Console.WriteLine(p);
        }

        // Creates a slice of the signal
        var slicedSignal = signal[1, 3];
        Console.WriteLine("Sliced Signal Real Parts:");
        foreach (var r in slicedSignal.Real)
        {
            Console.WriteLine(r);
        }

        // Creates a deep copy of the signal
        var copiedSignal = signal.Copy();
        Console.WriteLine("Copied Signal Real Parts:");
        foreach (var r in copiedSignal.Real)
        {
            Console.WriteLine(r);
        }
    }
}

Vorcyc.Mathematics.SignalProcessing.Signals.ComplexDiscreteSignalExtensions class

Vorcyc.Mathematics.SignalProcessing.Signals.ComplexDiscreteSignalExtensions provides extension methods for complex discrete signals.

Methods

1. Delay

public static ComplexDiscreteSignalFp32 Delay(this ComplexDiscreteSignalFp32 signal, int delay)
- Creates a delayed copy of signal by shifting right (positive delay) or left (negative delay).
- Parameters:
  - signal: signal.
  - delay: delay in samples (positive or negative)..
- Returns: delayed ComplexDiscreteSignalFp32.
public static ComplexDiscreteSignal<T> Delay<T>(this ComplexDiscreteSignal<T> signal, int delay) where T : unmanaged, IFloatingPointIeee754<T>, IMinMaxValue<T>
- Creates a delayed copy of signal by shifting right (positive delay) or left (negative delay).
- Parameters:
  - signal: signal.
  - delay: delay in samples (positive or negative)..
- Returns: delayed ComplexDiscreteSignal<T>.

2. Superimpose

public static ComplexDiscreteSignalFp32 Superimpose(this ComplexDiscreteSignalFp32 signal1, ComplexDiscreteSignalFp32 signal2)
- Superimposes signal1 and signal2; if sizes differ, the smaller signal is broadcast to match the larger.
- Parameters:
  - signal1: first signal..
  - signal2: second signal..
- Returns: superimposed ComplexDiscreteSignalFp32.
public static ComplexDiscreteSignal<T> Superimpose<T>(this ComplexDiscreteSignal<T> signal1, ComplexDiscreteSignal<T> signal2) where T : unmanaged, IFloatingPointIeee754<T>, IMinMaxValue<T>
- Superimposes signal1 and signal2; if sizes differ, the smaller signal is broadcast to match the larger.
- Parameters:
  - signal1: first signal..
  - signal2: second signal..
- Returns: superimposed ComplexDiscreteSignal<T>.

3. Concatenate

public static ComplexDiscreteSignalFp32 Concatenate(this ComplexDiscreteSignalFp32 signal1, ComplexDiscreteSignalFp32 signal2)
- Concatenates signal1 and signal2.
- Parameters:
  - signal1: first signal..
  - signal2: second signal..
- Returns: concatenated ComplexDiscreteSignalFp32.
public static ComplexDiscreteSignal<T> Concatenate<T>(this ComplexDiscreteSignal<T> signal1, ComplexDiscreteSignal<T> signal2) where T : unmanaged, IFloatingPointIeee754<T>, IMinMaxValue<T>
- Concatenates signal1 and signal2.
- Parameters:
  - signal1: first signal..
  - signal2: second signal..
- Returns: concatenated ComplexDiscreteSignal<T>.

4. Repeat

public static ComplexDiscreteSignalFp32 Repeat(this ComplexDiscreteSignalFp32 signal, int n)
- Creates a copy of signal repeated n times.
- Parameters:
  - signal: signal.
  - n: repeat count..
- Returns: repeated ComplexDiscreteSignalFp32.
public static ComplexDiscreteSignal<T> Repeat<T>(this ComplexDiscreteSignal<T> signal, int n) where T : unmanaged, IFloatingPointIeee754<T>, IMinMaxValue<T>
- Creates a copy of signal repeated n times.
- Parameters:
  - signal: signal.
  - n: repeat count..
- Returns: repeated ComplexDiscreteSignal<T>.

5. Amplify

public static void Amplify(this ComplexDiscreteSignalFp32 signal, float coeff)
- Amplifies signal by coeff.
- Parameters:
  - signal: signal.
  - coeff: amplification coefficient..
public static void Amplify<T>(this ComplexDiscreteSignal<T> signal, T coeff) where T : unmanaged, IFloatingPointIeee754<T>, IMinMaxValue<T>
- Amplifies signal by coeff.
- Parameters:
  - signal: signal.
  - coeff: amplification coefficient..

6. Attenuate

public static void Attenuate(this ComplexDiscreteSignalFp32 signal, float coeff)
- Attenuates signal by coeff.
- Parameters:
  - signal: signal.
  - coeff: attenuation coefficient..
public static void Attenuate<T>(this ComplexDiscreteSignal<T> signal, T coeff) where T : unmanaged, IFloatingPointIeee754<T>, IMinMaxValue<T>
- Attenuates signal by coeff.
- Parameters:
  - signal: signal.
  - coeff: attenuation coefficient..

7. First

public static ComplexDiscreteSignalFp32 First(this ComplexDiscreteSignalFp32 signal, int n)
- Creates a new signal from the first n samples of signal.
- Parameters:
  - signal: signal.
  - n: sample count.
- Returns: new ComplexDiscreteSignalFp32.
public static ComplexDiscreteSignal<T> First<T>(this ComplexDiscreteSignal<T> signal, int n) where T : unmanaged, IFloatingPointIeee754<T>, IMinMaxValue<T>
- Creates a new signal from the first n samples of signal.
- Parameters:
  - signal: signal.
  - n: sample count.
- Returns: new ComplexDiscreteSignal<T>.

8. Last

public static ComplexDiscreteSignalFp32 Last(this ComplexDiscreteSignalFp32 signal, int n)
- Creates a new signal from the last n samples of signal.
- Parameters:
  - signal: signal.
  - n: sample count.
- Returns: new ComplexDiscreteSignalFp32.
public static ComplexDiscreteSignal<T> Last<T>(this ComplexDiscreteSignal<T> signal, int n) where T : unmanaged, IFloatingPointIeee754<T>, IMinMaxValue<T>
- Creates a new signal from the last n samples of signal.
- Parameters:
  - signal: signal.
  - n: sample count.
- Returns: new ComplexDiscreteSignal<T>.

9. ZeroPadded

public static ComplexDiscreteSignalFp32 ZeroPadded(this ComplexDiscreteSignalFp32 signal, int length)
- Creates a new zero-padded complex discrete signal from signal.
- Parameters:
  - signal: signal.
  - length: length of zero-padded signal..
- Returns: zero-padded ComplexDiscreteSignalFp32.
public static ComplexDiscreteSignal<T> ZeroPadded<T>(this ComplexDiscreteSignal<T> signal, int length) where T : unmanaged, IFloatingPointIeee754<T>, IMinMaxValue<T>
- Creates a new zero-padded complex discrete signal from signal.
- Parameters:
  - signal: signal.
  - length: length of zero-padded signal..
- Returns: zero-padded ComplexDiscreteSignal<T>.

10. Multiply

public static ComplexDiscreteSignalFp32 Multiply(this ComplexDiscreteSignalFp32 signal1, ComplexDiscreteSignalFp32 signal2)
- Performs complex multiplication of signal1 and signal2 (normalized by length).
- Parameters:
  - signal1: first signal..
  - signal2: second signal..
- Returns: multiplied ComplexDiscreteSignalFp32.
public static ComplexDiscreteSignal<T> Multiply<T>(this ComplexDiscreteSignal<T> signal1, ComplexDiscreteSignal<T> signal2) where T : unmanaged, IFloatingPointIeee754<T>, IMinMaxValue<T>
- Performs complex multiplication of signal1 and signal2 (normalized by length).
- Parameters:
  - signal1: first signal..
  - signal2: second signal..
- Returns: multiplied ComplexDiscreteSignal<T>.

11. Divide

public static ComplexDiscreteSignalFp32 Divide(this ComplexDiscreteSignalFp32 signal1, ComplexDiscreteSignalFp32 signal2)
- Performs complex division of signal1 and signal2 (normalized by length).
- Parameters:
  - signal1: first signal..
  - signal2: second signal..
- Returns: divided ComplexDiscreteSignalFp32.
public static ComplexDiscreteSignal<T> Divide<T>(this ComplexDiscreteSignal<T> signal1, ComplexDiscreteSignal<T> signal2) where T : unmanaged, IFloatingPointIeee754<T>, IMinMaxValue<T>
- Performs complex division of signal1 and signal2 (normalized by length).
- Parameters:
  - signal1: first signal..
  - signal2: second signal..
- Returns: divided ComplexDiscreteSignal<T>.

12. Unwrap

public static float[] Unwrap(this float[] phase, float tolerance = ConstantsFp32.PI)
- Unwraps phase of complex samples.
- Parameters:
  - phase: phase.
  - tolerance: hop size, default ConstantsFp32.PI..
- Returns: unwrapped phase array.
public static T[] Unwrap<T>(this T[] phase, T? tolerance = null) where T : unmanaged, IFloatingPointIeee754<T>, IMinMaxValue<T>
- Unwraps phase of complex samples.
- Parameters:
  - phase: phase.
  - tolerance: hop size, default T.Pi..
- Returns: unwrapped phase array.

13. ToComplexNumbers

public static IEnumerable<ComplexFp32> ToComplexNumbers(this ComplexDiscreteSignalFp32 signal)
- Generates complex numbers from signal samples.
- Parameters:
  - signal: complexdiscretesignal.
- Returns: sequence of complex numbers.
public static IEnumerable<Complex<T>> ToComplexNumbers<T>(this ComplexDiscreteSignal<T> signal) where T : unmanaged, IFloatingPointIeee754<T>, IMinMaxValue<T>
- Generates complex numbers from signal samples.
- Parameters:
  - signal: complexdiscretesignal.
- Returns: sequence of complex numbers.

Code example

The following example uses ComplexDiscreteSignalExtensions with comments:

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

public class ComplexDiscreteSignalExtensionsExample
{
    public static void Main()
    {
        // Define sample rate
        int samplingRate = 44100;

        // Define real and imaginary arrays
        float[] real = { 0.5f, 0.6f, 0.55f };
        float[] imag = { 0.1f, 0.2f, 0.15f };

        // Create ComplexDiscreteSignalFp32 instance
        var signal = new ComplexDiscreteSignalFp32(samplingRate, real, imag);

        // Createsdelaysignal
        var delayedSignal = signal.Delay(2);
        Console.WriteLine("Delayed Signal Real Parts:");
        foreach (var r in delayedSignal.Real)
        {
            Console.WriteLine(r);
        }

        // superimposesignal
        var superimposedSignal = signal.Superimpose(delayedSignal);
        Console.WriteLine("Superimposed Signal Real Parts:");
        foreach (var r in superimposedSignal.Real)
        {
            Console.WriteLine(r);
        }

        // Concatenate signal
        var concatenatedSignal = signal.Concatenate(delayedSignal);
        Console.WriteLine("Concatenated Signal Real Parts:");
        foreach (var r in concatenatedSignal.Real)
        {
            Console.WriteLine(r);
        }

        // Amplify signal
        signal.Amplify(2.0f);
        Console.WriteLine("Amplified Signal Real Parts:");
        foreach (var r in signal.Real)
        {
            Console.WriteLine(r);
        }

        // Attenuate signal
        signal.Attenuate(2.0f);
        Console.WriteLine("Attenuated Signal Real Parts:");
        foreach (var r in signal.Real)
        {
            Console.WriteLine(r);
        }

        // Get first n samples
        var firstSamples = signal.First(2);
        Console.WriteLine("First Samples Real Parts:");
        foreach (var r in firstSamples.Real)
        {
            Console.WriteLine(r);
        }

        // Get last n samples
        var lastSamples = signal.Last(2);
        Console.WriteLine("Last Samples Real Parts:");
        foreach (var r in lastSamples.Real)
        {
            Console.WriteLine(r);
        }

        // zero-padded signal
        var zeroPaddedSignal = signal.ZeroPadded(8);
        Console.WriteLine("Zero Padded Signal Real Parts:");
        foreach (var r in zeroPaddedSignal.Real)
        {
            Console.WriteLine(r);
        }

        // complex multiplication
        var multipliedSignal = signal.Multiply(delayedSignal);
        Console.WriteLine("Multiplied Signal Real Parts:");
        foreach (var r in multipliedSignal.Real)
        {
            Console.WriteLine(r);
        }

        // complex division
        var dividedSignal = signal.Divide(delayedSignal);
        Console.WriteLine("Divided Signal Real Parts:");
        foreach (var r in dividedSignal.Real)
        {
            Console.WriteLine(r);
        }

        // Unwrap phase
        var unwrappedPhase = signal.Phase.Unwrap();
        Console.WriteLine("Unwrapped Phase:");
        foreach (var p in unwrappedPhase)
        {
            Console.WriteLine(p);
        }

        // Convert to complex
        var complexNumbers = signal.ToComplexNumbers();
        Console.WriteLine("Complex Numbers:");
        foreach (var c in complexNumbers)
        {
            Console.WriteLine($"Real: {c.Real}, Imaginary: {c.Imaginary}");
        }
    }
}

Vorcyc.Mathematics.SignalProcessing.Signals.ComplexDiscreteSignalFp32<T> class

Vorcyc.Mathematics.SignalProcessing.Signals.ComplexDiscreteSignal<T> represents a finite complex discrete-time signal stored as real and imaginary arrays at a given sample rate.

Properties

1. SamplingRate

public int SamplingRate { get; }
- Gets sample rate (samples per second).

2. Real

public T[] Real { get; }
- Gets real part of complex sample.

3. Imag

public T[] Imag { get; }
- Gets imaginary part of complex sample.

4. Length

public int Length => Real.Length
- Gets signal length.

5. Magnitude

public T[] Magnitude
- Gets magnitude of complex sample.

6. Power

public T[] Power
- Gets power of complex sample (amplitude squared).

7. Phase

public T[] Phase
- Gets phase of complex sample.

8. PhaseUnwrapped

public T[] PhaseUnwrapped
- Gets unwrapped phase of complex sample.

Methods

1. ComplexDiscreteSignalFp32 constructor

public ComplexDiscreteSignalFp32(int samplingRate, T[] real, T[]? imag = null, bool allocateNew = false)
- Constructs from real and imaginary arrays ComplexDiscreteSignalFp32 instance.
- Parameters:
  - samplingRate: signal sample rate..
  - real: real-part array of complex signal..
  - imag: imaginary-part array of complex signal; default null..
  - allocateNew: if new memory should be allocated for data, set to true; default false..
public ComplexDiscreteSignalFp32(int samplingRate, IEnumerable<T> real, IEnumerable<T>? imag = null)
- Constructs from real and imaginary sets ComplexDiscreteSignalFp32 instance.
- Parameters:
  - samplingRate: signal sample rate..
  - real: real-part set of complex signal..
  - imag: imaginary-part set of complex signal; default null..
public ComplexDiscreteSignalFp32(int samplingRate, IEnumerable<Complex<T>> samples)
- Constructs from complex sample set ComplexDiscreteSignalFp32 instance.
- Parameters:
  - samplingRate: signal sample rate..
  - samples: complex sample set..
public ComplexDiscreteSignalFp32(int samplingRate, int length, T real = default, T imag = default)
- Constructssignal with specified length filled with specified value.
- Parameters:
  - samplingRate: signal sample rate..
  - length: sample count.
  - real: real part value per sample; default 0.0..
  - imag: imaginary part value per sample; default 0.0..
public ComplexDiscreteSignalFp32(int samplingRate, IEnumerable<T> samples, T? normalizeFactor = null)
- constructs signal from integer sample set and normalizes at given sample rate.
- Parameters:
  - samplingRate: signal sample rate..
  - samples: integer sample set..
  - normalizeFactor: each sample is divided by this value; default 1.0..

2. Copy

public ComplexDiscreteSignal<T> Copy()
- Creates a deep copy of the signal.
- Returns: deep copy of the signal.

3.. Indexers

public T this[int index] { get; set; }
- Sample indexer; applies to real-part array only; use with care.
- Parameters:
  - index: sample index..
- Returns: real part value of sample.
public ComplexDiscreteSignal<T> this[int startPos, int endPos] { get; }
- Creates a slice of the signal.
- Parameters:
  - startPos: index of first sample (inclusive)..
  - endPos: index of last sample (exclusive)..
- Returns: slice of the signal.

Operator overloads

1. operator +

public static ComplexDiscreteSignal<T> operator +(ComplexDiscreteSignal<T> s1, ComplexDiscreteSignal<T> s2)
- creates new signal by superimposing s1 and s2; if sizes differ, smaller signal is broadcast to match larger.
- Parameters:
  - s1: first signal..
  - s2: second signal..
- Returns: new superimposed signal.
public static ComplexDiscreteSignal<T> operator +(ComplexDiscreteSignal<T> s, T constant)
- creates new signal by adding constant to signal s.
- Parameters:
  - s: signal.
  - constant: constant to add to each sample..
- Returns: new signal after adding constant.

2. operator -

public static ComplexDiscreteSignal<T> operator -(ComplexDiscreteSignal<T> s, T constant)
- creates new signal by subtracting constant from signal s.
- Parameters:
  - s: signal.
  - constant: constant to subtract from each sample..
- Returns: new signal after subtracting constant.

3. operator *

public static ComplexDiscreteSignal<T> operator *(ComplexDiscreteSignal<T> s, T coeff)
- creates new signal by multiplying signal s by coefficient (amplify/attenuate).
- Parameters:
  - s: signal.
  - coeff: amplify/attenuate coefficient..
- Returns: new signal after multiplying by coefficient.

Code example

The following example uses ComplexDiscreteSignal<T> with comments:

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

public class ComplexDiscreteSignalExample
{
    public static void Main()
    {
        // Define sample rate
        int samplingRate = 44100;

        // Define real and imaginary arrays
        float[] real = { 0.5f, 0.6f, 0.55f };
        float[] imag = { 0.1f, 0.2f, 0.15f };

        // Create ComplexDiscreteSignalFp32 instance
        var signal = new ComplexDiscreteSignal<float>(samplingRate, real, imag);

        // Print signal real and imaginary parts
        Console.WriteLine("Real Parts:");
        foreach (var r in signal.Real)
        {
            Console.WriteLine(r);
        }

        Console.WriteLine("Imaginary Parts:");
        foreach (var i in signal.Imag)
        {
            Console.WriteLine(i);
        }

        // Get and print signal magnitude
        var magnitude = signal.Magnitude;
        Console.WriteLine("Magnitude:");
        foreach (var m in magnitude)
        {
            Console.WriteLine(m);
        }

        // Get and print signal phase
        var phase = signal.Phase;
        Console.WriteLine("Phase:");
        foreach (var p in phase)
        {
            Console.WriteLine(p);
        }

        // Creates a slice of the signal
        var slicedSignal = signal[1, 3];
        Console.WriteLine("Sliced Signal Real Parts:");
        foreach (var r in slicedSignal.Real)
        {
            Console.WriteLine(r);
        }

        // Creates a deep copy of the signal
        var copiedSignal = signal.Copy();
        Console.WriteLine("Copied Signal Real Parts:");
        foreach (var r in copiedSignal.Real)
        {
            Console.WriteLine(r);
        }
    }
}

Vorcyc.Mathematics.SignalProcessing.Signals.DiscreteSignal class

Vorcyc.Mathematics.SignalProcessing.Signals.DiscreteSignal represents a finite real discrete-time signal stored as a single array at a given sample rate.

Properties

1. SamplingRate

public int SamplingRate { get; }
- Gets sample rate (samples per second).

2. SampleCount

public int SampleCount { get; }
- Gets sample count (fixed after allocation).

3. ValidSampleCount

public int ValidSampleCount { get; }
- Gets effective sample count.

4. Duration

public TimeSpan Duration { get; }
- Gets signal duration.

5. Samples

public PinnableArray<float> Samples { get; }
- Gets signal sample array.

6. MemoryStrategy

public MemoryStrategy MemoryStrategy { get; }
- Gets signal memory strategy.

Methods

1. DiscreteSignal constructor

public DiscreteSignal(int samplingRate, TimeSpan duration, MemoryStrategy strategy = MemoryStrategy.Immediate)
- Constructs DiscreteSignal from sample rate and duration.
- Parameters:
  - samplingRate: signal sample rate..
  - duration: signal duration..
  - strategy: memory strategy; default MemoryStrategy.Immediate..
public DiscreteSignal(int samplingRate, int count, MemoryStrategy strategy = MemoryStrategy.Immediate)
- Constructs DiscreteSignal from sample rate and sample count.
- Parameters:
  - samplingRate: signal sample rate..
  - count: sample count..
  - strategy: memory strategy; default MemoryStrategy.Immediate..
public DiscreteSignal(int samplingRate, float[] samples, MemoryStrategy strategy = MemoryStrategy.Immediate)
- Constructs DiscreteSignal from sample rate and sample array.
- Parameters:
  - samplingRate: signal sample rate..
  - samples: sample array..
  - strategy: memory strategy; default MemoryStrategy.Immediate..
public DiscreteSignal(int samplingRate, float[] samples, int offset, int count, MemoryStrategy strategy = MemoryStrategy.Immediate)
- Constructs DiscreteSignal from sample rate, sample array, offset, and count.
- Parameters:
  - samplingRate: signal sample rate..
  - samples: sample array..
  - offset: offset into sample array..
  - count: sample count..
  - strategy: memory strategy; default MemoryStrategy.Immediate..
public DiscreteSignal(int samplingRate, IEnumerable<float> samples, MemoryStrategy strategy = MemoryStrategy.Immediate)
- Constructs DiscreteSignal from sample rate and sample set.
- Parameters:
  - samplingRate: signal sample rate..
  - samples: Sample set.
  - strategy: memory strategy; default MemoryStrategy.Immediate..
public DiscreteSignal(int samplingRate, ArraySegment<float> segment, MemoryStrategy strategy = MemoryStrategy.Immediate)
- Constructs DiscreteSignal from sample rate and sample segment.
- Parameters:
  - samplingRate: signal sample rate..
  - segment: sample segment..
  - strategy: memory strategy; default MemoryStrategy.Immediate..
public DiscreteSignal(int samplingRate, Span<float> span, MemoryStrategy strategy = MemoryStrategy.Immediate)
- Constructs DiscreteSignal from sample rate and sample span.
- Parameters:
  - samplingRate: signal sample rate..
  - span: sample span..
  - strategy: memory strategy; default MemoryStrategy.Immediate..

2. Clone

public DiscreteSignal Clone()
- Creates a deep copy of the signal.
- Returns: deep copy of the signal.

3.. Indexers

public float this[int index] { get; set; }
- Sample indexer.
- Parameters:
  - index: sample index..
- Returns: sampleValue.
public DiscreteSignal this[int startPos, int endPos] { get; }
- Creates a slice of the signal.
- Parameters:
  - startPos: index of first sample (inclusive)..
  - endPos: index of last sample (exclusive)..
- Returns: slice of the signal.
public DiscreteSignal this[Range range] { get; }
- Creates a slice of the signal.
- Parameters:
  - range: sample range..
- Returns: slice of the signal.

4. Energy

public float Energy(int startPos, int endPos)
- Computes energy of signal segment.
- Parameters:
  - startPos: index of first sample (inclusive)..
  - endPos: index of last sample (exclusive)..
- Returns: energy of signal segment.
public float Energy(Range range)
- Computes energy of signal segment.
- Parameters:
  - range: sample range..
- Returns: energy of signal segment.
public float Energy()
- Computes energy of entire signal.
- Returns: energy of entire signal.

5. Rms

public float Rms(int startPos, int endPos)
- Computes RMS of signal segment.
- Parameters:
  - startPos: index of first sample (inclusive)..
  - endPos: index of last sample (exclusive)..
- Returns: RMS of signal segment.
public float Rms(Range range)
- Computes RMS of signal segment.
- Parameters:
  - range: sample range..
- Returns: RMS of signal segment.
public float Rms()
- Computes RMS of entire signal.
- Returns: RMS of entire signal.

6. ZeroCrossingRate

public float ZeroCrossingRate(int startPos, int endPos)
- Computes zero-crossing rate of signal segment.
- Parameters:
  - startPos: index of first sample (inclusive)..
  - endPos: index of last sample (exclusive)..
- Returns: zero-crossing rate of signal segment.
public float ZeroCrossingRate(Range range)
- Computes zero-crossing rate of signal segment.
- Parameters:
  - range: sample range..
- Returns: zero-crossing rate of signal segment.
public float ZeroCrossingRate()
- Computes zero-crossing rate of entire signal.
- Returns: zero-crossing rate of entire signal.

7. Entropy

public float Entropy(int startPos, int endPos, int binCount = 32)
- Computes Shannon entropy of signal segment.
- Parameters:
  - startPos: index of first sample (inclusive)..
  - endPos: index of last sample (exclusive)..
  - binCount: histogram bin count; default 32..
- Returns: Shannon entropy of signal segment.
public float Entropy(Range range, int binCount = 32)
- Computes Shannon entropy of signal segment.
- Parameters:
  - range: sample range..
  - binCount: histogram bin count; default 32..
- Returns: Shannon entropy of signal segment.
public float Entropy(int binCount = 32)
- Computes Shannon entropy of entire signal.
- Parameters:
  - binCount: histogram bin count; default 32..
- Returns: Shannon entropy of entire signal.

Operator overloads

1. operator +

public static DiscreteSignal operator +(DiscreteSignal s1, DiscreteSignal s2)
- creates new signal by superimposing s1 and s2; if sizes differ, smaller signal is broadcast to match larger.
- Parameters:
  - s1: first signal..
  - s2: second signal..
- Returns: new superimposed signal.
public static DiscreteSignal operator +(DiscreteSignal s, float constant)
- creates new signal by adding constant to signal s.
- Parameters:
  - s: signal.
  - constant: constant to add to each sample..
- Returns: new signal after adding constant.

2. operator -

public static DiscreteSignal operator -(DiscreteSignal s)
- Creates an inverted copy of signal s.
- Parameters:
  - s: signal.
- Returns: new inverted signal.
public static DiscreteSignal operator -(DiscreteSignal s1, DiscreteSignal s2)
- Creates new signal by subtracting s2 from s1; if sizes differ, smaller signal is broadcast to match larger.
- Parameters:
  - s1: first signal..
  - s2: second signal..
- Returns: new signal after subtraction.
public static DiscreteSignal operator -(DiscreteSignal s, float constant)
- creates new signal by subtracting constant from signal s.
- Parameters:
  - s: signal.
  - constant: constant to subtract from each sample..
- Returns: new signal after subtracting constant.

3. operator *

public static DiscreteSignal operator *(DiscreteSignal s, float coeff)
- creates new signal by multiplying signal s by coefficient (amplify/attenuate).
- Parameters:
  - s: signal.
  - coeff: amplify/attenuate coefficient..
- Returns: new signal after multiplying by coefficient.

Code example

The following example uses DiscreteSignal with comments:

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

public class DiscreteSignalExample
{
    public static void Main()
    {
        // Define sample rate
        int samplingRate = 44100;

        // Define sample array
        float[] samples = { 0.5f, 0.6f, 0.55f };

        // Create DiscreteSignal instance
        var signal = new DiscreteSignal(samplingRate, samples);

        // Print signal samples
        Console.WriteLine("Samples:");
        foreach (var sample in signal.Samples)
        {
            Console.WriteLine(sample);
        }

        // Get and print signal energy
        var energy = signal.Energy();
        Console.WriteLine("Energy:");
        Console.WriteLine(energy);

        // Get and print signal RMS
        var rms = signal.Rms();
        Console.WriteLine("RMS:");
        Console.WriteLine(rms);

        // Get and print signal zero-crossing rate
        var zeroCrossingRate = signal.ZeroCrossingRate();
        Console.WriteLine("Zero Crossing Rate:");
        Console.WriteLine(zeroCrossingRate);

        // Get and print signal Shannon entropy
        var entropy = signal.Entropy();
        Console.WriteLine("Entropy:");
        Console.WriteLine(entropy);

        // Creates a slice of the signal
        var slicedSignal = signal[1, 3];
        Console.WriteLine("Sliced Signal Samples:");
        foreach (var sample in slicedSignal.Samples)
        {
            Console.WriteLine(sample);
        }

        // Creates a deep copy of the signal
        var copiedSignal = signal.Clone();
        Console.WriteLine("Copied Signal Samples:");
        foreach (var sample in copiedSignal.Samples)
        {
            Console.WriteLine(sample);
        }
    }
}

Vorcyc.Mathematics.SignalProcessing.Signals.DiscreteSignal<TSample> class

Vorcyc.Mathematics.SignalProcessing.Signals.DiscreteSignal<TSample> represents a finite real discrete-time signal stored as a single array at a given sample rate.

Properties

1. SamplingRate

public int SamplingRate { get; }
- Gets sample rate (samples per second).

2. SampleCount

public int SampleCount { get; }
- Gets sample count (fixed after allocation).

3. ValidSampleCount

public int ValidSampleCount { get; }
- Gets effective sample count.

4. Duration

public TimeSpan Duration { get; }
- Gets signal duration.

5. Samples

public PinnableArray<TSample> Samples { get; }
- Gets signal sample array.

6. MemoryStrategy

public MemoryStrategy MemoryStrategy { get; }
- Gets signal memory strategy.

Methods

1. DiscreteSignal constructor

public DiscreteSignal(int samplingRate, TimeSpan duration, MemoryStrategy strategy = MemoryStrategy.Immediate)
- Constructs DiscreteSignal from sample rate and duration.
- Parameters:
  - samplingRate: signal sample rate..
  - duration: signal duration..
  - strategy: memory strategy; default MemoryStrategy.Immediate..
public DiscreteSignal(int samplingRate, int count, MemoryStrategy strategy = MemoryStrategy.Immediate)
- Constructs DiscreteSignal from sample rate and sample count.
- Parameters:
  - samplingRate: signal sample rate..
  - count: sample count..
  - strategy: memory strategy; default MemoryStrategy.Immediate..
public DiscreteSignal(int samplingRate, TSample[] samples, MemoryStrategy strategy = MemoryStrategy.Immediate)
- Constructs DiscreteSignal from sample rate and sample array.
- Parameters:
  - samplingRate: signal sample rate..
  - samples: sample array..
  - strategy: memory strategy; default MemoryStrategy.Immediate..
public DiscreteSignal(int samplingRate, TSample[] samples, int offset, int count, MemoryStrategy strategy = MemoryStrategy.Immediate)
- Constructs DiscreteSignal from sample rate, sample array, offset, and count.
- Parameters:
  - samplingRate: signal sample rate..
  - samples: sample array..
  - offset: offset into sample array..
  - count: sample count..
  - strategy: memory strategy; default MemoryStrategy.Immediate..
public DiscreteSignal(int samplingRate, IEnumerable<TSample> samples, MemoryStrategy strategy = MemoryStrategy.Immediate)
- Constructs DiscreteSignal from sample rate and sample set.
- Parameters:
  - samplingRate: signal sample rate..
  - samples: Sample set.
  - strategy: memory strategy; default MemoryStrategy.Immediate..
public DiscreteSignal(int samplingRate, ArraySegment<TSample> segment, MemoryStrategy strategy = MemoryStrategy.Immediate)
- Constructs DiscreteSignal from sample rate and sample segment.
- Parameters:
  - samplingRate: signal sample rate..
  - segment: sample segment..
  - strategy: memory strategy; default MemoryStrategy.Immediate..
public DiscreteSignal(int samplingRate, Span<TSample> span, MemoryStrategy strategy = MemoryStrategy.Immediate)
- Constructs DiscreteSignal from sample rate and sample span.
- Parameters:
  - samplingRate: signal sample rate..
  - span: sample span..
  - strategy: memory strategy; default MemoryStrategy.Immediate..

2. Clone

public DiscreteSignal<TSample> Clone()
- Creates a deep copy of the signal.
- Returns: deep copy of the signal.

3.. Indexers

public TSample this[int index] { get; set; }
- Sample indexer.
- Parameters:
  - index: sample index..
- Returns: sampleValue.
public DiscreteSignal<TSample> this[int startPos, int endPos] { get; }
- Creates a slice of the signal.
- Parameters:
  - startPos: index of first sample (inclusive)..
  - endPos: index of last sample (exclusive)..
- Returns: slice of the signal.
public DiscreteSignal<TSample> this[Range range] { get; }
- Creates a slice of the signal.
- Parameters:
  - range: sample range..
- Returns: slice of the signal.

4. Energy

public TSample Energy(int startPos, int endPos)
- Computes energy of signal segment.
- Parameters:
  - startPos: index of first sample (inclusive)..
  - endPos: index of last sample (exclusive)..
- Returns: energy of signal segment.
public TSample Energy(Range range)
- Computes energy of signal segment.
- Parameters:
  - range: sample range..
- Returns: energy of signal segment.
public TSample Energy()
- Computes energy of entire signal.
- Returns: energy of entire signal.

5. Rms

public TSample Rms(int startPos, int endPos)
- Computes RMS of signal segment.
- Parameters:
  - startPos: index of first sample (inclusive)..
  - endPos: index of last sample (exclusive)..
- Returns: RMS of signal segment.
public TSample Rms(Range range)
- Computes RMS of signal segment.
- Parameters:
  - range: sample range..
- Returns: RMS of signal segment.
public TSample Rms()
- Computes RMS of entire signal.
- Returns: RMS of entire signal.

6. ZeroCrossingRate

public TSample ZeroCrossingRate(int startPos, int endPos)
- Computes zero-crossing rate of signal segment.
- Parameters:
  - startPos: index of first sample (inclusive)..
  - endPos: index of last sample (exclusive)..
- Returns: zero-crossing rate of signal segment.
public TSample ZeroCrossingRate(Range range)
- Computes zero-crossing rate of signal segment.
- Parameters:
  - range: sample range..
- Returns: zero-crossing rate of signal segment.
public TSample ZeroCrossingRate()
- Computes zero-crossing rate of entire signal.
- Returns: zero-crossing rate of entire signal.

7. Entropy

public TSample Entropy(int startPos, int endPos, int binCount = 32)
- Computes Shannon entropy of signal segment.
- Parameters:
  - startPos: index of first sample (inclusive)..
  - endPos: index of last sample (exclusive)..
  - binCount: histogram bin count; default 32..
- Returns: Shannon entropy of signal segment.
public TSample Entropy(Range range, int binCount = 32)
- Computes Shannon entropy of signal segment.
- Parameters:
  - range: sample range..
  - binCount: histogram bin count; default 32..
- Returns: Shannon entropy of signal segment.
public TSample Entropy(int binCount = 32)
- Computes Shannon entropy of entire signal.
- Parameters:
  - binCount: histogram bin count; default 32..
- Returns: Shannon entropy of entire signal.

Operator overloads

1. operator +

public static DiscreteSignal<TSample> operator +(DiscreteSignal<TSample> s1, DiscreteSignal<TSample> s2)
- creates new signal by superimposing s1 and s2; if sizes differ, smaller signal is broadcast to match larger.
- Parameters:
  - s1: first signal..
  - s2: second signal..
- Returns: new superimposed signal.
public static DiscreteSignal<TSample> operator +(DiscreteSignal<TSample> s, TSample constant)
- creates new signal by adding constant to signal s.
- Parameters:
  - s: signal.
  - constant: constant to add to each sample..
- Returns: new signal after adding constant.

2. operator -

public static DiscreteSignal<TSample> operator -(DiscreteSignal<TSample> s)
- Creates an inverted copy of signal s.
- Parameters:
  - s: signal.
- Returns: new inverted signal.
public static DiscreteSignal<TSample> operator -(DiscreteSignal<TSample> s1, DiscreteSignal<TSample> s2)
- Creates new signal by subtracting s2 from s1; if sizes differ, smaller signal is broadcast to match larger.
- Parameters:
  - s1: first signal..
  - s2: second signal..
- Returns: new signal after subtraction.
public static DiscreteSignal<TSample> operator -(DiscreteSignal<TSample> s, TSample constant)
- creates new signal by subtracting constant from signal s.
- Parameters:
  - s: signal.
  - constant: constant to subtract from each sample..
- Returns: new signal after subtracting constant.

3. operator *

public static DiscreteSignal<TSample> operator *(DiscreteSignal<TSample> s, TSample coeff)
- creates new signal by multiplying signal s by coefficient (amplify/attenuate).
- Parameters:
  - s: signal.
  - coeff: amplify/attenuate coefficient..
- Returns: new signal after multiplying by coefficient.

Code example

The following example uses DiscreteSignal<TSample> with comments:

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

public class DiscreteSignalExample
{
    public static void Main()
    {
        // Define sample rate
        int samplingRate = 44100;

        // Define sample array
        float[] samples = { 0.5f, 0.6f, 0.55f };

        // Create DiscreteSignal instance
        var signal = new DiscreteSignal<float>(samplingRate, samples);

        // Print signal samples
        Console.WriteLine("Samples:");
        foreach (var sample in signal.Samples)
        {
            Console.WriteLine(sample);
        }

        // Get and print signal energy
        var energy = signal.Energy();
        Console.WriteLine("Energy:");
        Console.WriteLine(energy);

        // Get and print signal RMS
        var rms = signal.Rms();
        Console.WriteLine("RMS:");
        Console.WriteLine(rms);

        // Get and print signal zero-crossing rate
        var zeroCrossingRate = signal.ZeroCrossingRate();
        Console.WriteLine("Zero Crossing Rate:");
        Console.WriteLine(zeroCrossingRate);

        // Get and print signal Shannon entropy
        var entropy = signal.Entropy();
        Console.WriteLine("Entropy:");
        Console.WriteLine(entropy);

        // Creates a slice of the signal
        var slicedSignal = signal[1, 3];
        Console.WriteLine("Sliced Signal Samples:");
        foreach (var sample in slicedSignal.Samples)
        {
            Console.WriteLine(sample);
        }

        // Creates a deep copy of the signal
        var copiedSignal = signal.Clone();
        Console.WriteLine("Copied Signal Samples:");
        foreach (var sample in copiedSignal.Samples)
        {
            Console.WriteLine(sample);
        }
    }
}

Vorcyc.Mathematics.SignalProcessing.Signals.DiscreteSignalExtensions class

Vorcyc.Mathematics.SignalProcessing.Signals.DiscreteSignalExtensions provides extension methods for discrete signals.

Methods

1. Delay

public static DiscreteSignal Delay(this DiscreteSignal signal, int delay)
- Creates a delayed copy of signal by shifting right (positive delay) or left (negative delay).
- Parameters:
  - signal: signal.
  - delay: delay in samples (positive or negative)..
- Returns: delayed DiscreteSignal.

2. Superimpose

public static DiscreteSignal Superimpose(this DiscreteSignal signal1, DiscreteSignal signal2)
- Superimposes signal1 and signal2; if sizes differ, the smaller signal is broadcast to match the larger.
- Parameters:
  - signal1: first signal..
  - signal2: second signal..
- Returns: superimposed DiscreteSignal.

3. SuperimposeMany

public static DiscreteSignal SuperimposeMany(this DiscreteSignal signal1, DiscreteSignal signal2, int[] positions)
- Superimposes signal2 onto signal1 at given positions multiple times.
- Parameters:
  - signal1: first signal..
  - signal2: second signal..
  - positions: positions (indices) to insert signal2..
- Returns: superimposed DiscreteSignal.

4. Subtract

public static DiscreteSignal Subtract(this DiscreteSignal signal1, DiscreteSignal signal2)
- Subtracts signal2 from signal1; if sizes differ, smaller signal is broadcast to match larger.
- Parameters:
  - signal1: first signal..
  - signal2: second signal..
- Returns: resulting DiscreteSignal after subtraction.

5. Concatenate

public static DiscreteSignal Concatenate(this DiscreteSignal signal1, DiscreteSignal signal2)
- Concatenates signal1 and signal2.
- Parameters:
  - signal1: first signal..
  - signal2: second signal..
- Returns: concatenated DiscreteSignal.

6. Repeat

public static DiscreteSignal Repeat(this DiscreteSignal signal, int n)
- Creates a copy of signal repeated n times.
- Parameters:
  - signal: signal.
  - n: repeat count..
- Returns: repeated DiscreteSignal.

7. Amplify

public static void Amplify(this DiscreteSignal signal, float coeff)
- Amplifies signal by coeff.
- Parameters:
  - signal: signal.
  - coeff: amplification coefficient..

8. Attenuate

public static void Attenuate(this DiscreteSignal signal, float coeff)
- Attenuates signal by coeff.
- Parameters:
  - signal: signal.
  - coeff: attenuation coefficient..

9. Reverse

public static void Reverse(this DiscreteSignal signal)
- reverse signal.
- Parameters:
  - signal: signal.

10. First

public static DiscreteSignal First(this DiscreteSignal signal, int n)
- Creates a new signal from the first n samples of signal.
- Parameters:
  - signal: signal.
  - n: sample count.
- Returns: new DiscreteSignal.

11. Last

public static DiscreteSignal Last(this DiscreteSignal signal, int n)
- Creates a new signal from the last n samples of signal.
- Parameters:
  - signal: signal.
  - n: sample count.
- Returns: new DiscreteSignal.

12. FullRectify

public static void FullRectify(this DiscreteSignal signal)
- Full-wave rectifies signal.
- Parameters:
  - signal: signal.

13. HalfRectify

public static void HalfRectify(this DiscreteSignal signal)
- Half-wave rectifies signal.
- Parameters:
  - signal: signal.

14. NormalizeMax

public static void NormalizeMax(this DiscreteSignal signal, int bitsPerSample = 0)
- Normalizes signal by max absolute value (range [-1, 1]).
- Parameters:
  - signal: signal.
  - bitsPerSample: bits per sample; default 0..

15. ToComplex

public static ComplexDiscreteSignalFp32 ToComplex(this DiscreteSignal signal)
- Creates ComplexDiscreteSignalFp32 from DiscreteSignal with zero imaginary part.
- Parameters:
  - signal: real-valued signal..
- Returns: complexValuesignal ComplexDiscreteSignalFp32.

16. FadeInFadeOut

public static void FadeInFadeOut(this DiscreteSignal signal, double fadeInDuration, double fadeOutDuration)
- Applies linear fade in/out to signal.
- Parameters:
  - signal: signal.
  - fadeInDuration: fade induration (seconds).
  - fadeOutDuration: fade outduration (seconds).
public static void FadeInFadeOut(this DiscreteSignal signal, TimeSpan fadeInDuration, TimeSpan fadeOutDuration)
- Applies linear fade in/out to signal.
- Parameters:
  - signal: signal.
  - fadeInDuration: fade induration.
  - fadeOutDuration: fade outduration.

17. FadeIn

public static void FadeIn(this DiscreteSignal signal, double duration)
- Applies linear fade in to signal.
- Parameters:
  - signal: signal.
  - duration: fade induration (seconds).
public static void FadeIn(this DiscreteSignal signal, TimeSpan duration)
- Applies linear fade in to signal.
- Parameters:
  - signal: signal.
  - duration: fade induration.

18. FadeOut

public static void FadeOut(this DiscreteSignal signal, double duration)
- Applies linear fade out to signal.
- Parameters:
  - signal: signal.
  - duration: fade outduration (seconds).
public static void FadeOut(this DiscreteSignal signal, TimeSpan duration)
- Applies linear fade out to signal.
- Parameters:
  - signal: signal.
  - duration: fade outduration.

19. Crossfade

public static DiscreteSignal Crossfade(this DiscreteSignal signal1, DiscreteSignal signal2, double duration)
- Linearly crossfades between signal1 and signal2; result length equals sum of lengths minus crossfade region.
- Parameters:
  - signal1: first signal..
  - signal2: second signal..
  - duration: crossfadeduration (seconds).
- Returns: crossfaded DiscreteSignal.
public static DiscreteSignal Crossfade(this DiscreteSignal signal1, DiscreteSignal signal2, TimeSpan duration)
- Linearly crossfades between signal1 and signal2; result length equals sum of lengths minus crossfade region.
- Parameters:
  - signal1: first signal..
  - signal2: second signal..
  - duration: crossfadeduration.
- Returns: crossfaded DiscreteSignal.

Code example

The following example uses DiscreteSignalExtensions with comments:

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

public class DiscreteSignalExtensionsExample
{
    public static void Main()
    {
        // Define sample rate
        int samplingRate = 44100;

        // Define sample array
        float[] samples = { 0.5f, 0.6f, 0.55f };

        // Create DiscreteSignal instance
        var signal = new DiscreteSignal(samplingRate, samples);

        // Createsdelaysignal
        var delayedSignal = signal.Delay(2);
        Console.WriteLine("Delayed Signal Samples:");

        foreach (var sample in delayedSignal.Samples)
        {
            Console.WriteLine(sample);
        }

        // superimposesignal
        var superimposedSignal = signal.Superimpose(delayedSignal);
        Console.WriteLine("Superimposed Signal Samples:");

        foreach (var sample in superimposedSignal.Samples)
        {
            Console.WriteLine(sample);
        }

        // Concatenate signal
        var concatenatedSignal = signal.Concatenate(delayedSignal);
        Console.WriteLine("Concatenated Signal Samples:");

        foreach (var sample in concatenatedSignal.Samples)
        {
            Console.WriteLine(sample);
        }

        // Amplify signal
        signal.Amplify(2.0f);
        Console.WriteLine("Amplified Signal Samples:");

        foreach (var sample in signal.Samples)
        {
            Console.WriteLine(sample);
        }

        // Attenuate signal
        signal.Attenuate(2.0f);
        Console.WriteLine("Attenuated Signal Samples:");

        foreach (var sample in signal.Samples)
        {
            Console.WriteLine(sample);
        }

        // Get first n samples
        var firstSamples = signal.First(2);
        Console.WriteLine("First Samples:");

        foreach (var sample in firstSamples.Samples)
        {
            Console.WriteLine(sample);
        }

        // Get last n samples
        var lastSamples = signal.Last(2);
        Console.WriteLine("Last Samples:");

        foreach (var sample in lastSamples.Samples)
        {
            Console.WriteLine(sample);
        }

        // full-wave rectified signal
        signal.FullRectify();
        Console.WriteLine("Full Rectified Signal Samples:");

        foreach (var sample in signal.Samples)
        {
            Console.WriteLine(sample);
        }

        // half-wave rectified signal
        signal.HalfRectify();
        Console.WriteLine("Half Rectified Signal Samples:");

        foreach (var sample in signal.Samples)
        {
            Console.WriteLine(sample);
        }

        // normalizedsignal
        signal.NormalizeMax();
        Console.WriteLine("Normalized Signal Samples:");

        foreach (var sample in signal.Samples)
        {
            Console.WriteLine(sample);
        }

        // fadesignal
        signal.FadeInFadeOut(0.1, 0.1);
        Console.WriteLine("Fade In Fade Out Signal Samples:");

        foreach (var sample in signal.Samples)
        {
            Console.WriteLine(sample);
        }

        // crossfadesignal
        var crossfadedSignal = signal.Crossfade(delayedSignal, 0.1);
        Console.WriteLine("Crossfaded Signal Samples:");

        foreach (var sample in crossfadedSignal.Samples)
        {
            Console.WriteLine(sample);
        }
    }
}

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_Signals

Signal Processing Module

Signals

Generators (0.9+)

WaveShape / GenerateWave

Vorcyc.Mathematics.SignalProcessing.Signals.Signal class

Constructors and factories

Main properties

Slicing and copying

Frequency domain and resampling

Operators

Code example

Vorcyc.Mathematics.SignalProcessing.Signals.SignalSegment struct

Vorcyc.Mathematics.SignalProcessing.Signals.SignalExtensions class

Vorcyc.Mathematics.SignalProcessing.Signals.ComplexDiscreteSignalFp32 class

Properties

1. SamplingRate

2. Real

3. Imag

4. Length

5. Magnitude

6. Power

7. Phase

8. PhaseUnwrapped

Methods

1. ComplexDiscreteSignalFp32 constructor

2. Copy

3.. Indexers

Operator overloads

1. operator +

2. operator -

3. operator *

Code example

Vorcyc.Mathematics.SignalProcessing.Signals.ComplexDiscreteSignalFp32<T> class

Properties

1. SamplingRate

2. Real

3. Imag

4. Length

5. Magnitude

6. Power

7. Phase

8. PhaseUnwrapped

Methods

1. ComplexDiscreteSignalFp32 constructor

2. Copy

3.. Indexers

Operator overloads

1. operator +

2. operator -

3. operator *

Code example

Vorcyc.Mathematics.SignalProcessing.Signals.ComplexDiscreteSignalExtensions class

Methods

1. Delay

2. Superimpose

3. Concatenate

4. Repeat

5. Amplify

6. Attenuate

7. First

8. Last

9. ZeroPadded

10. Multiply

11. Divide

12. Unwrap

13. ToComplexNumbers

Code example

Vorcyc.Mathematics.SignalProcessing.Signals.ComplexDiscreteSignalFp32<T> class

Properties

1. SamplingRate

2. Real

3. Imag

4. Length

5. Magnitude

6. Power

7. Phase

8. PhaseUnwrapped

Methods

1. ComplexDiscreteSignalFp32 constructor

`WaveShape` / `GenerateWave`