Module_SignalProcessing_Windowing

Location: Home / Signal processing / Windowing

Signal Processing Module

Windowing

The Vorcyc.Mathematics.SignalProcessing.Windowing namespace contains window computation and application classes: WindowApplier, WindowBuilder, and WindowBuilderExtensions. WindowApplier provides rectangular, triangular, Hamming, Blackman, Hann, Gaussian, Kaiser, KBD, Bartlett-Hann, Lanczos, power-of-sine, flat-top, liftering, and Blackman-Harris windows. WindowBuilder generates window coefficient arrays. WindowBuilderExtensions applies windows to signals and sample arrays.

WindowType enum (in this namespace) lists the available window kinds used by WindowBuilder.OfType and the ApplyWindow overloads: Rectangular, Triangular, Hamming, HammingPeriodic, Blackman, BlackmanPeriodic, Hann, HannPeriodic, Gaussian, Kaiser, Kbd, BartlettHann, Lanczos, PowerOfSine, Flattop, Liftering, BlackmanHarris.

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

📒 Contents

🔖 Vorcyc.Mathematics.SignalProcessing.Windowing.WindowApplier class
🔖 Vorcyc.Mathematics.SignalProcessing.Windowing.WindowBuilder class
🔖 Vorcyc.Mathematics.SignalProcessing.Windowing.WindowBuilderExtensions class

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

Vorcyc.Mathematics.SignalProcessing.Windowing.WindowApplier class

Vorcyc.Mathematics.SignalProcessing.Windowing.WindowApplier provides multiple window computation methods.

Methods

1. Rectangular

public static void Rectangular(Span<ComplexFp32> values)
- Computes rectangular window.
- Parameters:
  - values: Input data.

2. Triangular

public static void Triangular(Span<ComplexFp32> values)
- Computes triangular window.
- Parameters:
  - values: Input data.

3. Hamming

public static void Hamming(Span<ComplexFp32> values)
- Computes Hamming window.
- Parameters:
  - values: Input data.

4. Blackman

public static void Blackman(Span<ComplexFp32> values)
- Computes Blackman window.
- Parameters:
  - values: Input data.

5. Hann

public static void Hann(Span<ComplexFp32> values)
- Computes Hann window.
- Parameters:
  - values: Input data.

6. Gaussian

public static void Gaussian(Span<ComplexFp32> values)
- Computes Gaussian window.
- Parameters:
  - values: Input data.

7. Kaiser

public static void Kaiser(Span<ComplexFp32> values, float alpha = 12f)
- Computes Kaiser window.
- Parameters:
  - values: Input data.
  - alpha: Alpha parameter.

8. Kbd

public static void Kbd(Span<ComplexFp32> values, float alpha = 4f)
- Computes Kaiser-Bessel derived (KBD) window.
- Parameters:
  - values: Input data.
  - alpha: Alpha parameter.

9. Bartlett_Hann

public static void Bartlett_Hann(Span<ComplexFp32> values)
- Computes Bartlett-Hann window.
- Parameters:
  - values: Input data.

10. Lanczos

public static void Lanczos(Span<ComplexFp32> values)
- Computes Lanczos window.
- Parameters:
  - values: Input data.

11. PowerOfSine

public static void PowerOfSine(Span<ComplexFp32> values, float alpha = 1.5f)
- Computes power-of-sine window.
- Parameters:
  - values: Input data.
  - alpha: Alpha parameter.

12. Flattop

public static void Flattop(Span<ComplexFp32> values)
- Computes flat-top window.
- Parameters:
  - values: Input data.

13. Liftering

public static void Liftering(Span<ComplexFp32> values, int l = 22)
- Computes liftering window.
- Parameters:
  - values: Input data.
  - l: L parameter.

14. Blackman_Harris

public static void Blackman_Harris(Span<ComplexFp32> values)
- Computes Blackman-Harris window.
- Parameters:
  - values: Input data.

15. Apply

public static void Apply(Span<ComplexFp32> values, WindowType windowType)
- Applies the specified window.
- Parameters:
  - values: Input data.
  - windowType: Window type。

Code example

The following example uses WindowApplier with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Windowing;
using Vorcyc.Mathematics.Numerics;

public class WindowApplierExample
{
    public static void Main()
    {
        // Define input data
        var values = new ComplexFp32[] { new ComplexFp32(1.0f, 0.0f), new ComplexFp32(2.0f, 0.0f), new ComplexFp32(3.0f, 0.0f), new ComplexFp32(4.0f, 0.0f), new ComplexFp32(5.0f, 0.0f), new ComplexFp32(6.0f, 0.0f), new ComplexFp32(7.0f, 0.0f), new ComplexFp32(8.0f, 0.0f) };

        // Apply triangular window
        WindowApplier.Triangular(values);
        Console.WriteLine("Triangular Window:");

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

        // Apply Hamming window
        WindowApplier.Hamming(values);
        Console.WriteLine("Hamming Window:");

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

        // Apply Blackman window
        WindowApplier.Blackman(values);
        Console.WriteLine("Blackman Window:");

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

        // Apply Hann window
        WindowApplier.Hann(values);
        Console.WriteLine("Hann Window:");

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

        // Apply Gaussian window
        WindowApplier.Gaussian(values);
        Console.WriteLine("Gaussian Window:");

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

        // Apply Kaiser window
        WindowApplier.Kaiser(values);
        Console.WriteLine("Kaiser Window:");

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

        // Apply KBD window
        WindowApplier.Kbd(values);
        Console.WriteLine("Kbd Window:");

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

        // Apply Bartlett-Hann window
        WindowApplier.Bartlett_Hann(values);
        Console.WriteLine("Bartlett-Hann Window:");

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

        // Apply Lanczos window
        WindowApplier.Lanczos(values);
        Console.WriteLine("Lanczos Window:");

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

        // Apply power-of-sine window
        WindowApplier.PowerOfSine(values);
        Console.WriteLine("PowerOfSine Window:");

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

        // Apply flat-top window
        WindowApplier.Flattop(values);
        Console.WriteLine("Flattop Window:");

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

        // Apply liftering window
        WindowApplier.Liftering(values);
        Console.WriteLine("Liftering Window:");

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

        // Apply Blackman-Harris window
        WindowApplier.Blackman_Harris(values);
        Console.WriteLine("Blackman-Harris Window:");

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

Vorcyc.Mathematics.SignalProcessing.Windowing.WindowBuilder class

Vorcyc.Mathematics.SignalProcessing.Windowing.WindowBuilder provides methods to generate window coefficients of various types.

Methods

1. OfType

public static float[] OfType(WindowType type, int length, params object[] parameters)
- Generates window coefficients of the given type and length.
- Parameters:
  - type: Window type。
  - length: Window length。
  - parameters: Additional optional parameters.
- Returns: Window coefficient array。

2. Rectangular

public static float[] Rectangular(int length)
- Generates rectangular window.
- Parameters:
  - length: Window length。
- Returns: Window coefficient array。

3. Triangular

public static float[] Triangular(int length)
- Generates triangular window.
- Parameters:
  - length: Window length。
- Returns: Window coefficient array。

4. Hamming

public static float[] Hamming(int length)
- Generates Hamming window.
- Parameters:
  - length: Window length。
- Returns: Window coefficient array。

5. Blackman

public static float[] Blackman(int length)
- Generates Blackman window.
- Parameters:
  - length: Window length。
- Returns: Window coefficient array。

6. Hann

public static float[] Hann(int length)
- Generates Hann window.
- Parameters:
  - length: Window length。
- Returns: Window coefficient array。

7. Gaussian

public static float[] Gaussian(int length)
- Generates Gaussian window. The window is symmetric for every length (including even lengths); a length of 1 returns [1].
- Parameters:
  - length: Window length。
- Returns: Window coefficient array。

8. Kaiser

public static float[] Kaiser(int length, double alpha = 12.0)
- Generates Kaiser window of given length and alpha.
- Parameters:
  - length: Window length。
  - alpha: Alpha parameter.
- Returns: Window coefficient array。

9. Kbd

public static float[] Kbd(int length, double alpha = 4.0)
- Generates KBD window of given length and alpha.
- Parameters:
  - length: Window length。
  - alpha: Alpha parameter.
- Returns: Window coefficient array。

10. BartlettHann

public static float[] BartlettHann(int length)
- Generates Bartlett-Hann window.
- Parameters:
  - length: Window length。
- Returns: Window coefficient array。

11. Lanczos

public static float[] Lanczos(int length)
- Generates Lanczos window.
- Parameters:
  - length: Window length。
- Returns: Window coefficient array。

12. PowerOfSine

public static float[] PowerOfSine(int length, double alpha = 1.5)
- Generates power-of-sine window of given length and alpha.
- Parameters:
  - length: Window length。
  - alpha: Alpha parameter.
- Returns: Window coefficient array。

13. Flattop

public static float[] Flattop(int length)
- Generates flat-top window.
- Parameters:
  - length: Window length。
- Returns: Window coefficient array。

14. Liftering

public static float[] Liftering(int length, int l = 22)
- Generates liftering window of given length and l parameter.
- Parameters:
  - length: Window length。
  - l: L parameter.
- Returns: Window coefficient array。

15. Blackman_Harris

public static float[] Blackman_Harris(int length)
- Generates Blackman-Harris window.
- Parameters:
  - length: Window length。
- Returns: Window coefficient array。

Code example

The following example uses WindowBuilder with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Windowing;

public class WindowBuilderExample
{
    public static void Main()
    {
        // Define window length
        int length = 8;

        // Generate triangular window coefficients
        var triangular = WindowBuilder.Triangular(length);
        Console.WriteLine("Triangular Window:");

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

        // Generate Hamming window coefficients
        var hamming = WindowBuilder.Hamming(length);
        Console.WriteLine("Hamming Window:");

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

        // Generate Blackman window coefficients
        var blackman = WindowBuilder.Blackman(length);
        Console.WriteLine("Blackman Window:");

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

        // Generate Hann window coefficients
        var hann = WindowBuilder.Hann(length);
        Console.WriteLine("Hann Window:");

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

        // Generate Gaussian window coefficients
        var gaussian = WindowBuilder.Gaussian(length);
        Console.WriteLine("Gaussian Window:");

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

        // Generate Kaiser window coefficients
        var kaiser = WindowBuilder.Kaiser(length);
        Console.WriteLine("Kaiser Window:");

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

        // Generate KBD window coefficients
        var kbd = WindowBuilder.Kbd(length);
        Console.WriteLine("Kbd Window:");

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

        // Generate Bartlett-Hann window coefficients
        var bartlettHann = WindowBuilder.BartlettHann(length);
        Console.WriteLine("Bartlett-Hann Window:");

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

        // Generate Lanczos window coefficients
        var lanczos = WindowBuilder.Lanczos(length);
        Console.WriteLine("Lanczos Window:");

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

        // Generate power-of-sine window coefficients
        var powerOfSine = WindowBuilder.PowerOfSine(length);
        Console.WriteLine("PowerOfSine Window:");

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

        // Generate flat-top window coefficients
        var flattop = WindowBuilder.Flattop(length);
        Console.WriteLine("Flattop Window:");

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

        // Generate liftering window coefficients
        var liftering = WindowBuilder.Liftering(length);
        Console.WriteLine("Liftering Window:");

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

        // Generate Blackman-Harris window coefficients
        var blackmanHarris = WindowBuilder.Blackman_Harris(length);
        Console.WriteLine("Blackman-Harris Window:");

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

Vorcyc.Mathematics.SignalProcessing.Windowing.WindowBuilderExtensions class

Vorcyc.Mathematics.SignalProcessing.Windowing.WindowBuilderExtensions provides extension methods to apply windows to signals and sample arrays.

Methods

1. ApplyWindow (float[])

public static void ApplyWindow(this float[] samples, float[] windowSamples)
- Applies window to sample array.
- Parameters:
  - samples: Sample array.
  - windowSamples: Window coefficients.

2. ApplyWindow (double[])

public static void ApplyWindow(this double[] samples, double[] windowSamples)
- Applies window to sample array.
- Parameters:
  - samples: Sample array.
  - windowSamples: Window coefficients.

3. ApplyWindow (Signal)

public static void ApplyWindow(this Signal signal, float[] windowSamples)
- Applies window to signal.
- Parameters:
  - signal: Signal.
  - windowSamples: Window coefficients.

4. ApplyWindow (float[], WindowType)

public static void ApplyWindow(this float[] samples, WindowType window, params object[] parameters)
- Applies window of specified type to sample array.
- Parameters:
  - samples: Sample array.
  - window: Window type。
  - parameters: Window parameters.

5. ApplyWindow (double[], WindowType)

public static void ApplyWindow(this double[] samples, WindowType window, params object[] parameters)
- Applies window of specified type to sample array.
- Parameters:
  - samples: Sample array.
  - window: Window type。
  - parameters: Window parameters.

6. ApplyWindow (Signal, WindowType)

public static void ApplyWindow(this Signal signal, WindowType window, params object[] parameters)
- Applies window of specified type to signal.
- Parameters:
  - signal: Signal.
  - window: WindowType。
  - parameters: Window parameters.

7. ApplyWindow (Span)

public static void ApplyWindow(this Span<float> samples, float[] windowSamples)
- Applies window in-place to a span of samples.
- Parameters:
  - samples: Sample span.
  - windowSamples: Window coefficients.

Code example

The following example uses WindowBuilderExtensions with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Windowing;
using Vorcyc.Mathematics.SignalProcessing.Signals;
public class WindowBuilderExtensionsExample
{
    public static void Main()
    {
        // Define sample array
        var samples = new float[] { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f };

        // Define window coefficients
        var windowSamples = WindowBuilder.Hamming(samples.Length);

        // Apply window to sample array
        samples.ApplyWindow(windowSamples);
        Console.WriteLine("Samples after applying Hamming window:");

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

        // Apply window of specified type to sample array
        samples.ApplyWindow(WindowType.Blackman);
        Console.WriteLine("Samples after applying Blackman window:");

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

        // Define signal
        var signal = Signal.FromCopy(samples, 8000f);

        // Apply window to signal
        signal.ApplyWindow(windowSamples);
        Console.WriteLine("Signal after applying Hamming window:");

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

        // Apply window of specified type to signal
        signal.ApplyWindow(WindowType.Blackman);
        Console.WriteLine("Signal after applying Blackman window:");

        foreach (var sample in signal.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_Windowing

Signal Processing Module

Windowing

Vorcyc.Mathematics.SignalProcessing.Windowing.WindowApplier class

Methods

1. Rectangular

2. Triangular

3. Hamming

4. Blackman

5. Hann

6. Gaussian

7. Kaiser

8. Kbd

9. Bartlett_Hann

10. Lanczos

11. PowerOfSine

12. Flattop

13. Liftering

14. Blackman_Harris

15. Apply

Code example

Vorcyc.Mathematics.SignalProcessing.Windowing.WindowBuilder class

Methods

1. OfType

2. Rectangular

3. Triangular

4. Hamming

5. Blackman

6. Hann

7. Gaussian

8. Kaiser

9. Kbd

10. BartlettHann

11. Lanczos

12. PowerOfSine

13. Flattop

14. Liftering

15. Blackman_Harris

Code example

Vorcyc.Mathematics.SignalProcessing.Windowing.WindowBuilderExtensions class

Methods

1. ApplyWindow (float[])

2. ApplyWindow (double[])

3. ApplyWindow (Signal)

4. ApplyWindow (float[], WindowType)

5. ApplyWindow (double[], WindowType)

6. ApplyWindow (Signal, WindowType)

7. ApplyWindow (Span)

Code example

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!