Module_SignalProcessing_Fourier_zh

信号处理模块 - Signal Processing Module

傅立叶变换 - Fourier Transform

Vorcyc.Mathematics.SignalProcessing.Fourier 命名空间提供 CPU 侧傅立叶变换。

0.10.1 重组：傅立叶家族已统一归入 Fourier/ 源文件夹与 Vorcyc.Mathematics.SignalProcessing.Fourier 命名空间。Fft、Fft64、RealFft、RealFft64、Stft 均从 Transforms/ 迁入此处；其中 RealFft、RealFft64、Stft 的命名空间也由 Vorcyc.Mathematics.SignalProcessing.Transforms 改为 .Fourier（Fft 与 Fft64 此前已在 Fourier 命名空间）。旧版 RealOnlyFFT_Fp32 类已移除，请改用 RealFft（或需要完整复数 I/O 时使用 Fft）。共享的 SoA radix-2 蝶形内核 FftButterflyFp32 / FftButterflyFp64 提供 Fft、Fft64、RealFft、RealFft64 所用的 SIMD 与并行执行路径。

静态类 FastFourierTransform 仍是基于指针 / ComplexFp32 变换的高层入口。

0.10.12：所有 FastFourierTransform.Forward / Inverse 重载（span、array、指针、就地，因而 ITimeDomainSignal.TransformToFrequencyDomain）在 SIMD / 并行划算时走与 Fft / RealFft 相同的 SoA FftButterflyFp32 核；低于 SIMD 交叉点仍用原来的标量 FastFourierTransformNormal。AoS FastFourierTransformSIMD / FastFourierTransformParallel、FftVersion 枚举与 FastFourierTransform.Version 已删除。请用 ComputingContext / ComputingScope。

0.10.13：Stft.AveragePeriodogram 仅平均完整窗（SciPy/MATLAB welch）；Operation.Welch 增加 ComputingContext?；RealFft.PowerSpectrum 增加带策略重载。 0.10.14：Operation.Welch onesided DC/Nyquist 不 ×2；RealFft/Fft 谱接口带策略重载；STFT 帧并行 NestedFrameFftContext；WindowBuilder.OfType 支持周期窗。 0.10.15：FrequencyDomain.IndexToFrequency 按 TransformLength（FFT 长度） 映射 bin，不再误用 ActualLength（未补零样点数）。补零 / Welch 后 onesided 谱右半 bin 不再读成错误负频率。 0.10.18：Fft<T> / RealFft<T> 将 float 派发到 Fft/RealFft，将 double 派发到 Fft64/RealFft64。模态分解走这些门面，样本缓冲留在 T。

0.9+：请使用 ComputingContext 指定 FFT 执行策略（Forward(..., context)、Direct(..., context) 或 ComputingScope）。

GPU / CUDA：主包不含 CUDA FFT（已移除 CudaFFT / ILGPU）。说明见 GPU 策略说明。CPU 原生 FFT 可选 Extensions.FFTW。

以下类型均位于命名空间：Vorcyc.Mathematics.SignalProcessing.Fourier

📒目录

🔖 Vorcyc.Mathematics.SignalProcessing.Fourier.FastFourierTransform 类
🔖 Vorcyc.Mathematics.SignalProcessing.Fourier.Fft 类
🔖 Vorcyc.Mathematics.SignalProcessing.Fourier.Fft64 类
🔖 Vorcyc.Mathematics.SignalProcessing.Fourier.Fft<T> 类
🔖 Vorcyc.Mathematics.SignalProcessing.Fourier.RealFft 类
🔖 Vorcyc.Mathematics.SignalProcessing.Fourier.RealFft64 类
🔖 Vorcyc.Mathematics.SignalProcessing.Fourier.RealFft<T> 类
🔖 Vorcyc.Mathematics.SignalProcessing.Fourier.Stft 类
🔖 FftButterflyFp32 / FftButterflyFp64（内部内核）

Vorcyc.Mathematics.SignalProcessing.Fourier.FastFourierTransform 类

Vorcyc.Mathematics.SignalProcessing.Fourier.FastFourierTransform 是一个用于实现快速傅里叶变换（FFT）的静态类。

方法

1. Forward

public static bool Forward(float* input, ComplexFp32* output, int N)
- 执行前向 FFT 变换，将实数输入转换为复数输出。
- 参数:
  - input: 输入数据，实数序列（时域）。
  - output: 变换结果，复数序列。
  - N: FFT 长度。
- 返回值: 是否成功。
public static bool Forward(float[] input, int offset, out ComplexFp32[] output, int N)
- 执行前向 FFT 变换，将实数输入转换为复数输出。
- 参数:
  - input: 输入数据，实数序列（时域）。
  - offset: 输入数据的偏移量。
  - output: 变换结果，复数序列。
  - N: FFT 长度。
- 返回值: 是否成功。
public static bool Forward(ReadOnlySpan<float> input, Span<ComplexFp32> output)
- 执行前向 FFT 变换，将实数输入转换为复数输出。
- 参数:
  - input: 输入数据，实数序列（时域）。
  - output: 变换结果，复数序列。
- 返回值: 是否成功。
public static bool Forward(ComplexFp32* input, ComplexFp32* output, int N)
- 执行前向 FFT 变换，将复数输入转换为复数输出。
- 参数:
  - input: 输入数据，复数序列（时域）。
  - output: 变换结果，复数序列。
  - N: FFT 长度。
- 返回值: 是否成功。
public static bool Forward(ReadOnlySpan<ComplexFp32> input, Span<ComplexFp32> output)
- 执行前向 FFT 变换，将复数输入转换为复数输出。
- 参数:
  - input: 输入数据，复数序列（时域）。
  - output: 变换结果，复数序列。
- 返回值: 是否成功。
public static bool Forward(ComplexFp32[] input, int offset, ComplexFp32[] output, int N)
- 执行前向 FFT 变换，将复数输入转换为复数输出。
- 参数:
  - input: 输入数据，复数序列（时域）。
  - offset: 输入数据的偏移量。
  - output: 变换结果，复数序列。
  - N: FFT 长度。
- 返回值: 是否成功。
public static bool Forward(ComplexFp32* data, int N)
- 执行前向 FFT 变换，原地版本。
- 参数:
  - data: 输入和输出数据，复数序列。
  - N: FFT 长度。
- 返回值: 是否成功。
public static bool Forward(ComplexFp32[] data, int offset, int N)
- 执行前向 FFT 变换，原地版本。
- 参数:
  - data: 输入和输出数据，复数序列。
  - offset: 数据的偏移量。
  - N: FFT 长度。
- 返回值: 是否成功。
public static bool Forward(Span<ComplexFp32> data)
- 执行前向 FFT 变换，原地版本。
- 参数:
  - data: 输入和输出数据，复数序列。
- 返回值: 是否成功。
public static bool Forward(float[] input, int offset, out ComplexFp32[] output, int N, ComputingContext? context)
- Forward(float[], int, out ComplexFp32[], int) 的带策略重载。0.10.12 起在划算时走 SoA FftButterflyFp32 的 SIMD / 并行核，否则走标量 FastFourierTransformNormal。
public static bool Forward(ReadOnlySpan<float> input, Span<ComplexFp32> output, ComputingContext? context)
- Forward(ReadOnlySpan<float>, Span<ComplexFp32>) 的带策略重载。
public static bool Forward(ReadOnlySpan<ComplexFp32> input, Span<ComplexFp32> output, ComputingContext? context)
- Forward(ReadOnlySpan<ComplexFp32>, Span<ComplexFp32>) 的带策略重载。

2. Inverse

public static bool Inverse(ComplexFp32* input, ComplexFp32* output, int N, bool scale = true)
- 执行逆向 FFT 变换，将复数输入转换为复数输出。
- 参数:
  - input: 输入数据，复数序列（频域）。
  - output: 变换结果，复数序列（时域）。
  - N: 输入长度。
  - scale: 是否缩放，默认为 true。
- 返回值: 是否成功。
public static bool Inverse(ComplexFp32[] input, int inOffset, out ComplexFp32[] output, int outOffset, int N, bool scale = true)
- 执行逆向 FFT 变换，将复数输入转换为复数输出。
- 参数:
  - input: 输入数据，复数序列（频域）。
  - inOffset: 输入数据的偏移量。
  - output: 变换结果，复数序列（时域）。
  - outOffset: 输出数据的偏移量。
  - N: 输入长度。
  - scale: 是否缩放，默认为 true。
- 返回值: 是否成功。
public static bool Inverse(ReadOnlySpan<ComplexFp32> input, Span<ComplexFp32> output, bool scale = true)
- 执行逆向 FFT 变换，将复数输入转换为复数输出。
- 参数:
  - input: 输入数据，复数序列（频域）。
  - output: 变换结果，复数序列（时域）。
  - scale: 是否缩放，默认为 true。
- 返回值: 是否成功。
public static bool Inverse(ComplexFp32* data, int N, bool scale = true)
- 执行逆向 FFT 变换，原地版本。
- 参数:
  - data: 输入和输出数据，复数序列（频域）。
  - N: 输入长度。
  - scale: 是否缩放，默认为 true。
- 返回值: 是否成功。
public static bool Inverse(ComplexFp32[] data, int offset, int N, bool scale = true)
- 执行逆向 FFT 变换，原地版本。
- 参数:
  - data: 输入和输出数据，复数序列（频域）。
  - offset: 数据的偏移量。
  - N: 输入长度。
  - scale: 是否缩放，默认为 true。
- 返回值: 是否成功。
public static bool Inverse(Span<ComplexFp32> data, bool scale = true)
- 执行逆向 FFT 变换，原地版本。
- 参数:
  - data: 输入和输出数据，复数序列（频域）。
  - scale: 是否缩放，默认为 true。
- 返回值: 是否成功。
public static bool Inverse(ComplexFp32[] input, int inOffset, out ComplexFp32[] output, int outOffset, int N, bool scale, ComputingContext? context)
- 数组版 Inverse(...) 的带策略重载。0.10.12 起在划算时走 FftButterflyFp32（与 Forward 同一套策略）。
public static bool Inverse(ReadOnlySpan<ComplexFp32> input, Span<ComplexFp32> output, bool scale, ComputingContext? context)
- Inverse(ReadOnlySpan<ComplexFp32>, Span<ComplexFp32>, bool) 的带策略重载。
public static bool Inverse(Span<ComplexFp32> data, bool scale, ComputingContext? context)
- Inverse(Span<ComplexFp32>, bool) 的就地带策略重载。

代码示例

以下是一个使用 FastFourierTransform 类中多个方法的示例，并在示例中加入了注释：

using System;
using Vorcyc.Mathematics.SignalProcessing.Fourier;

public class FastFourierTransformExample
{
    public static void Main()
    {
        // 定义输入信号
        float[] inputSignal = { 0.5f, 0.6f, 0.55f, 0.7f, 0.65f };

        // 执行前向 FFT 变换
        FastFourierTransform.Forward(inputSignal, 0, out var forwardOutput, inputSignal.Length);
        Console.WriteLine("Forward FFT Output:");
        foreach (var sample in forwardOutput)
        {
            Console.WriteLine($"Real: {sample.Real}, Imaginary: {sample.Imaginary}");
        }

        // 执行逆向 FFT 变换
        FastFourierTransform.Inverse(forwardOutput, 0, out var inverseOutput, 0, forwardOutput.Length);
        Console.WriteLine("Inverse FFT Output:");
        foreach (var sample in inverseOutput)
        {
            Console.WriteLine($"Real: {sample.Real}, Imaginary: {sample.Imaginary}");
        }
    }
}

Vorcyc.Mathematics.SignalProcessing.Fourier.Fft 类

Vorcyc.Mathematics.SignalProcessing.Fourier.Fft 是面向 float 数据的复数就地 radix-2 FFT，实现 IComplexTransform。变换在分开的实部 / 虚部数组上就地完成（结构数组 SoA）。带 ComputingContext 的重载在规模足够大时派发到共享的 SIMD / 并行蝶形内核，否则运行标量频率抽取蝶形。

属性

1. Size

public int Size { get; }
- 获取 FFT 大小。

方法

1. Fft 构造函数

public Fft(int fftSize = 512)
- 按给定 fftSize 构造 Fft 并预计算旋转因子表。FFT 大小必须是 2 的幂。
- 参数:
  - fftSize: FFT 大小。

2. Direct（就地）

public void Direct(float[] re, float[] im)
public void Direct(Span<float> re, Span<float> im)
- 在实部 / 虚部数组上就地执行前向 FFT。
- 参数:
  - re: 实部（输入与输出）。
  - im: 虚部（输入与输出）。
public void Direct(float[] re, float[] im, ComputingContext? context)
- 带执行策略的前向 FFT；按 context 选择标量 / SIMD / 并行。
- 参数:
  - re: 实部。
  - im: 虚部。
  - context: 可选执行策略。

3. Direct（拷贝版本）

public void Direct(float[] inRe, float[] inIm, float[] outRe, float[] outIm)
public void Direct(ReadOnlySpan<float> inRe, ReadOnlySpan<float> inIm, Span<float> outRe, Span<float> outIm)
- 先将输入拷贝到输出缓冲，再就地变换。
- 参数:
  - inRe / inIm: 输入实部 / 虚部。
  - outRe / outIm: 输出实部 / 虚部。

4. DirectNorm

public void DirectNorm(float[] inRe, float[] inIm, float[] outRe, float[] outIm)
public void DirectNorm(ReadOnlySpan<float> inRe, ReadOnlySpan<float> inIm, Span<float> outRe, Span<float> outIm)
- 归一化前向 FFT（拷贝版本）。对本类等价于 Direct(...)。

5. Inverse（就地）

public void Inverse(float[] re, float[] im)
public void Inverse(Span<float> re, Span<float> im)
- 就地逆变换。
public void Inverse(float[] re, float[] im, ComputingContext? context)
- 带执行策略的逆变换。

6. Inverse（拷贝版本）

public void Inverse(float[] inRe, float[] inIm, float[] outRe, float[] outIm)
public void Inverse(ReadOnlySpan<float> inRe, ReadOnlySpan<float> inIm, Span<float> outRe, Span<float> outIm)
- 先将输入拷贝到输出缓冲，再就地逆变换。

7. InverseNorm

public void InverseNorm(float[] re, float[] im)
public void InverseNorm(Span<float> re, Span<float> im)
- 就地归一化逆变换（除以 Size）。
public void InverseNorm(float[] re, float[] im, ComputingContext? context)
- 带执行策略的归一化逆变换。
public void InverseNorm(float[] inRe, float[] inIm, float[] outRe, float[] outIm)
public void InverseNorm(ReadOnlySpan<float> inRe, ReadOnlySpan<float> inIm, Span<float> outRe, Span<float> outIm)
- 归一化逆变换（拷贝版本）。

8. MagnitudeSpectrum

public void MagnitudeSpectrum(float[] samples, float[] spectrum, bool normalize = false)
public void MagnitudeSpectrum(ReadOnlySpan<float> samples, float[] spectrum, bool normalize = false)
public void MagnitudeSpectrum(ReadOnlySpan<float> samples, Span<float> spectrum, bool normalize = false)
- 由实数 samples 计算 spectrum = sqrt(re*re + im*im)。spectrum 长度至少为 Size/2 + 1。
public Signal MagnitudeSpectrum(Signal signal, bool normalize = false)
- 返回幅度谱作为 Signal。

9. PowerSpectrum

public void PowerSpectrum(float[] samples, float[] spectrum, bool normalize = true)
public void PowerSpectrum(ReadOnlySpan<float> samples, float[] spectrum, bool normalize = true)
public void PowerSpectrum(ReadOnlySpan<float> samples, Span<float> spectrum, bool normalize = true)
- 由实数 samples 计算 spectrum = re*re + im*im。
public float[] PowerSpectrum(Signal signal, bool normalize = true)
- 返回功率谱作为 float[]。

10. Shift（静态）

public static void Shift(float[] samples)
public static void Shift(Span<float> samples)
- 就地 FFT 移位（交换前后两半）。长度为奇数时抛出 ArgumentException。

代码示例

using System;
using Vorcyc.Mathematics.SignalProcessing.Fourier;

public class FftExample
{
    public static void Main()
    {
        int fftSize = 8;
        var fft = new Fft(fftSize);

        float[] re = { 1f, 2f, 3f, 4f, 5f, 6f, 7f, 8f };
        float[] im = new float[fftSize];

        // 就地前向 FFT
        fft.Direct(re, im);
        Console.WriteLine("Forward FFT:");
        for (int i = 0; i < fftSize; i++)
            Console.WriteLine($"re={re[i]}, im={im[i]}");

        // 就地归一化逆变换
        fft.InverseNorm(re, im);
        Console.WriteLine("Inverse (normalized):");
        for (int i = 0; i < fftSize; i++)
            Console.WriteLine($"re={re[i]}, im={im[i]}");
    }
}

Vorcyc.Mathematics.SignalProcessing.Fourier.Fft64 类

Vorcyc.Mathematics.SignalProcessing.Fourier.Fft64 是 Fft 的 double 精度对应物：复数就地 radix-2 FFT。带 ComputingContext 的重载在规模足够大时派发到 FftButterflyFp64 的 SIMD / 并行内核。

属性

1. Size

public int Size { get; }
- 获取 FFT 大小。

方法

1. Fft64 构造函数

public Fft64(int fftSize = 512)
- 按给定 fftSize 构造 Fft64。FFT 大小必须是 2 的幂。
- 参数:
  - fftSize: FFT 大小。

2. Direct（就地）

public void Direct(double[] re, double[] im)
public void Direct(Span<double> re, Span<double> im)
public void Direct(double[] re, double[] im, ComputingContext? context)
- 就地前向 FFT；带 context 的重载按策略选择标量 / SIMD / 并行。

3. Direct（拷贝版本）

public void Direct(double[] inRe, double[] inIm, double[] outRe, double[] outIm)
public void Direct(ReadOnlySpan<double> inRe, ReadOnlySpan<double> inIm, Span<double> outRe, Span<double> outIm)
- 先将输入拷贝到输出缓冲，再就地变换。

4. DirectNorm

public void DirectNorm(double[] inRe, double[] inIm, double[] outRe, double[] outIm)
public void DirectNorm(ReadOnlySpan<double> inRe, ReadOnlySpan<double> inIm, Span<double> outRe, Span<double> outIm)
- 归一化前向 FFT（拷贝版本）。

5. Inverse（就地）

public void Inverse(double[] re, double[] im)
public void Inverse(Span<double> re, Span<double> im)
public void Inverse(double[] re, double[] im, ComputingContext? context)
- 就地逆变换；带 context 的重载按策略选择标量 / SIMD / 并行。

6. Inverse（拷贝版本）

public void Inverse(double[] inRe, double[] inIm, double[] outRe, double[] outIm)
public void Inverse(ReadOnlySpan<double> inRe, ReadOnlySpan<double> inIm, Span<double> outRe, Span<double> outIm)
- 先将输入拷贝到输出缓冲，再就地逆变换。

7. InverseNorm

public void InverseNorm(double[] re, double[] im)
public void InverseNorm(Span<double> re, Span<double> im)
public void InverseNorm(double[] re, double[] im, ComputingContext? context)
public void InverseNorm(double[] inRe, double[] inIm, double[] outRe, double[] outIm)
public void InverseNorm(ReadOnlySpan<double> inRe, ReadOnlySpan<double> inIm, Span<double> outRe, Span<double> outIm)
- 归一化逆变换（就地、带策略、拷贝版本）。

代码示例

using System;
using Vorcyc.Mathematics.SignalProcessing.Fourier;

public class Fft64Example
{
    public static void Main()
    {
        int fftSize = 8;
        var fft = new Fft64(fftSize);

        double[] re = { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 };
        double[] im = new double[fftSize];

        fft.Direct(re, im);
        Console.WriteLine("Forward FFT64:");
        for (int i = 0; i < fftSize; i++)
            Console.WriteLine($"re={re[i]}, im={im[i]}");

        fft.InverseNorm(re, im);
        Console.WriteLine("Inverse (normalized):");
        for (int i = 0; i < fftSize; i++)
            Console.WriteLine($"re={re[i]}, im={im[i]}");
    }
}

Vorcyc.Mathematics.SignalProcessing.Fourier.Fft<T> 类

Fft<T>（0.10.18）是泛型复数 FFT 门面：float 派发到 Fft，double 派发到 Fft64。其他 T 抛 NotSupportedException。

方法

public Fft(int fftSize = 512)
public void Direct(T[] re, T[] im, ComputingContext? context = null)
public void Inverse(T[] re, T[] im, ComputingContext? context = null)
public void InverseNorm(T[] re, T[] im, ComputingContext? context = null)

var fft = new Fft<float>(256);
fft.Direct(re, im, ComputingContext.Simd);

Vorcyc.Mathematics.SignalProcessing.Fourier.RealFft<T> 类

RealFft<T>（0.10.18）是对应的实输入门面：float → RealFft，double → RealFft64。

方法

public RealFft(int size)
public void Direct(T[] input, T[] re, T[] im, ComputingContext? context = null)
public void Inverse(T[] re, T[] im, T[] output, ComputingContext? context = null)
public void InverseNorm(T[] re, T[] im, T[] output, ComputingContext? context = null)

Vorcyc.Mathematics.SignalProcessing.Fourier.RealFft 类

Vorcyc.Mathematics.SignalProcessing.Fourier.RealFft 是面向实数输入（float）的复数 FFT，实现 IComplexTransform。内部以半尺寸复数 FFT 实现，提供前向 / 逆 / 归一化逆变换、幅度谱与功率谱以及 FFT 移位工具。带 ComputingContext 的重载在规模足够大时为内部半尺寸变换派发到共享的 FftButterflyFp32 SIMD / 并行内核。本类替代已移除的 RealOnlyFFT_Fp32。

属性

1. Size

public int Size { get; }
- 获取 FFT 大小（配置的实输入长度）。

方法

1. RealFft 构造函数

public RealFft(int size)
- 按给定 size 构造 RealFft。FFT 大小必须是 2 的幂。
- 参数:
  - size: FFT 大小。

2. Direct

public void Direct(float[] input, float[] re, float[] im)
public void Direct(float[] input, float[] re, float[] im, ComputingContext? context)
public void Direct(ReadOnlySpan<float> input, Span<float> re, Span<float> im, ComputingContext? context = null)
- 前向 FFT：实数 input -> 复数 (re, im)。带 context 的重载为内部半尺寸变换选择标量 / SIMD / 并行。
public void Direct(float[] inRe, float[] inIm, float[] outRe, float[] outIm)
- IComplexTransform 签名；inIm 被忽略。

3. DirectNorm

public void DirectNorm(float[] inRe, float[] inIm, float[] outRe, float[] outIm)
- 归一化前向 FFT（IComplexTransform 签名；inIm 被忽略）。对本类等价于 Direct(...)。

4. Inverse

public void Inverse(float[] re, float[] im, float[] output)
public void Inverse(float[] re, float[] im, float[] output, ComputingContext? context)
public void Inverse(ReadOnlySpan<float> re, ReadOnlySpan<float> im, Span<float> output, ComputingContext? context = null)
- 逆变换：复数 (re, im) -> 实数 output。
public void Inverse(float[] inRe, float[] inIm, float[] outRe, float[] outIm)
- IComplexTransform 签名；outIm 被忽略。

5. InverseNorm

public void InverseNorm(float[] re, float[] im, float[] output)
public void InverseNorm(float[] re, float[] im, float[] output, ComputingContext? context)
public void InverseNorm(ReadOnlySpan<float> re, ReadOnlySpan<float> im, Span<float> output, ComputingContext? context = null)
- 归一化逆变换：复数 (re, im) -> 实数 output（除以半尺寸）。
public void InverseNorm(float[] inRe, float[] inIm, float[] outRe, float[] outIm)
- IComplexTransform 签名；outIm 被忽略。

6. MagnitudeSpectrum

public void MagnitudeSpectrum(float[] samples, float[] spectrum, bool normalize = false)
public void MagnitudeSpectrum(ReadOnlySpan<float> samples, float[] spectrum, bool normalize = false)
public void MagnitudeSpectrum(ReadOnlySpan<float> samples, Span<float> spectrum, bool normalize = false)
- 计算 spectrum = sqrt(re*re + im*im)。spectrum 长度至少为 Size/2 + 1。
public Signal MagnitudeSpectrum(Signal signal, bool normalize = false)
- 返回幅度谱作为 Signal。

7. PowerSpectrum

public void PowerSpectrum(float[] samples, float[] spectrum, bool normalize = true)
public void PowerSpectrum(ReadOnlySpan<float> samples, float[] spectrum, bool normalize = true)
public void PowerSpectrum(ReadOnlySpan<float> samples, Span<float> spectrum, bool normalize = true)
- 计算 spectrum = re*re + im*im。
public Signal PowerSpectrum(Signal signal, bool normalize = true)
- 返回功率谱作为 Signal。
public float[] PowerSpectrumArray(Signal signal, bool normalize = true)
- 返回功率谱作为 float[]。

8. Shift（静态）

public static void Shift(float[] samples)
public static void Shift(Span<float> samples)
- 就地 FFT 移位（交换前后两半）。长度为奇数时抛出 ArgumentException。

代码示例

using System;
using Vorcyc.Mathematics.SignalProcessing.Fourier;

public class RealFftExample
{
    public static void Main()
    {
        int fftSize = 8;
        var fft = new RealFft(fftSize);

        float[] input = { 0.5f, 0.6f, 0.55f, 0.7f, 0.65f, 0.8f, 0.75f, 0.9f };
        var re = new float[fftSize / 2 + 1];
        var im = new float[fftSize / 2 + 1];

        // 前向 FFT：实输入 -> 复数谱
        fft.Direct(input, re, im);
        Console.WriteLine("Forward FFT:");
        for (int i = 0; i < re.Length; i++)
            Console.WriteLine($"re={re[i]}, im={im[i]}");

        // 幅度谱 / 功率谱
        var mag = new float[re.Length];
        var pow = new float[re.Length];
        fft.MagnitudeSpectrum(input, mag);
        fft.PowerSpectrum(input, pow);

        // 逆变换：复数谱 -> 实输出
        var output = new float[fftSize];
        fft.InverseNorm(re, im, output);
        Console.WriteLine("Inverse (normalized):");
        foreach (var v in output) Console.WriteLine(v);
    }
}

Vorcyc.Mathematics.SignalProcessing.Fourier.RealFft64 类

Vorcyc.Mathematics.SignalProcessing.Fourier.RealFft64 是 RealFft 的 double 精度对应物：面向实数输入的复数 FFT。带 ComputingContext 的重载在规模足够大时为内部半尺寸变换派发到 FftButterflyFp64 的 SIMD / 并行内核。

属性

1. Size

public int Size { get; }
- 获取 FFT 大小（配置的实输入长度）。

方法

1. RealFft64 构造函数

public RealFft64(int size)
- 按给定 size 构造 RealFft64。FFT 大小必须是 2 的幂。
- 参数:
  - size: FFT 大小。

2. Direct

public void Direct(double[] input, double[] re, double[] im)
public void Direct(double[] input, double[] re, double[] im, ComputingContext? context)
public void Direct(ReadOnlySpan<double> input, Span<double> re, Span<double> im, ComputingContext? context = null)
- 前向 FFT：实数 input -> 复数 (re, im)。
public void Direct(double[] inRe, double[] inIm, double[] outRe, double[] outIm)
- IComplexTransform 风格签名；inIm 被忽略。

3. DirectNorm

public void DirectNorm(double[] inRe, double[] inIm, double[] outRe, double[] outIm)
- 归一化前向 FFT（inIm 被忽略）。对本类等价于 Direct(...)。

4. Inverse

public void Inverse(double[] re, double[] im, double[] output)
public void Inverse(double[] re, double[] im, double[] output, ComputingContext? context)
public void Inverse(ReadOnlySpan<double> re, ReadOnlySpan<double> im, Span<double> output, ComputingContext? context = null)
- 逆变换：复数 (re, im) -> 实数 output。
public void Inverse(double[] inRe, double[] inIm, double[] outRe, double[] outIm)
- IComplexTransform 风格签名；outIm 被忽略。

5. InverseNorm

public void InverseNorm(double[] re, double[] im, double[] output)
public void InverseNorm(double[] re, double[] im, double[] output, ComputingContext? context)
public void InverseNorm(ReadOnlySpan<double> re, ReadOnlySpan<double> im, Span<double> output, ComputingContext? context = null)
- 归一化逆变换：复数 (re, im) -> 实数 output。
public void InverseNorm(double[] inRe, double[] inIm, double[] outRe, double[] outIm)
- IComplexTransform 风格签名；outIm 被忽略。

代码示例

using System;
using Vorcyc.Mathematics.SignalProcessing.Fourier;

public class RealFft64Example
{
    public static void Main()
    {
        int fftSize = 8;
        var fft = new RealFft64(fftSize);

        double[] input = { 0.5, 0.6, 0.55, 0.7, 0.65, 0.8, 0.75, 0.9 };
        var re = new double[fftSize / 2 + 1];
        var im = new double[fftSize / 2 + 1];

        fft.Direct(input, re, im);

        var output = new double[fftSize];
        fft.InverseNorm(re, im, output);
        foreach (var v in output) Console.WriteLine(v);
    }
}

Vorcyc.Mathematics.SignalProcessing.Fourier.Stft 类

Vorcyc.Mathematics.SignalProcessing.Fourier.Stft 实现短时傅立叶变换及其逆变换，并附带谱图与幅度-相位谱图辅助方法。内部封装 RealFft 与窗函数（WindowBuilder）。所有处理方法接受可选的 ComputingContext：当工作量足够大时驱动帧级并行派发，否则使用串行路径。Stft 于 0.10.1 从 Vorcyc.Mathematics.SignalProcessing.Transforms 迁移至此。

属性

1. Size

public int Size { get; }
- 获取变换器使用的 FFT 大小。

方法

1. Stft 构造函数

public Stft(int windowSize = 1024, int hopSize = 256, WindowType window = WindowType.Hann, int fftSize = 0)
- 构造 Stft 变换器。当 fftSize < windowSize 时，FFT 大小取 windowSize 的下一个 2 的幂。
- 参数:
  - windowSize: 分析窗大小。
  - hopSize: 步长（重叠）大小。
  - window: 窗函数类型。
  - fftSize: FFT 大小；0 时按 windowSize 自动选取。

2. Direct

public List<(float[], float[])> Direct(float[] input, ComputingContext? context = null)
public List<(float[], float[])> Direct(ReadOnlySpan<float> input, ComputingContext? context = null)
public List<(float[], float[])> Direct(Signal signal, ComputingContext? context = null)
- 计算 STFT，返回逐帧谱列表 (re[], im[])。

3. Inverse

public float[] Inverse(List<(float[], float[])> stft, bool perfectReconstruction = true, ComputingContext? context = null)
- 通过重叠相加进行逆 STFT。当 perfectReconstruction 为 true 时，hopSize 不得超过 windowSize。

4. Spectrogram

public List<float[]> Spectrogram(float[] input, bool normalize = true, ComputingContext? context = null)
public List<float[]> Spectrogram(ReadOnlySpan<float> input, bool normalize = true, ComputingContext? context = null)
public List<float[]> Spectrogram(Signal signal, bool normalize = true, ComputingContext? context = null)
- 计算谱图，返回逐帧功率谱列表。

5. AveragePeriodogram

public float[] AveragePeriodogram(float[] input, ComputingContext? context = null)
public float[] AveragePeriodogram(ReadOnlySpan<float> input, ComputingContext? context = null)
public float[] AveragePeriodogram(Signal signal, ComputingContext? context = null)
- 计算 Welch 风格平均周期图：仅对完整窗的逐帧功率谱取均值（凑不满一窗的尾部样本丢弃，对齐 SciPy / MATLAB welch）。尊重 ComputingContext 做帧级并行；帧已并行时，帧内 FFT 走 SIMD（避免嵌套 Parallel）。

0.10.13：去掉原先的末尾不完整帧及 / (N+1) 平均。短信号 / 少帧场景为破坏性变更。

6. MagnitudePhaseSpectrogram

public MagnitudePhaseList MagnitudePhaseSpectrogram(float[] input, ComputingContext? context = null)
public MagnitudePhaseList MagnitudePhaseSpectrogram(ReadOnlySpan<float> input, ComputingContext? context = null)
public MagnitudePhaseList MagnitudePhaseSpectrogram(Signal signal, ComputingContext? context = null)
- 计算谱图，返回分开的幅度列表与相位列表。

7. ReconstructMagnitudePhase

public float[] ReconstructMagnitudePhase(MagnitudePhaseList spectrogram, bool perfectReconstruction = true, ComputingContext? context = null)
- 由幅度/相位谱图通过逆 STFT 重建样本。

MagnitudePhaseList 结构体

public struct MagnitudePhaseList
- public List<float[]> Magnitudes { get; set; } — 逐帧幅度列表。
- public List<float[]> Phases { get; set; } — 逐帧相位列表。

代码示例

using System;
using Vorcyc.Mathematics.SignalProcessing.Fourier;

public class StftExample
{
    public static void Main()
    {
        var stft = new Stft(windowSize: 1024, hopSize: 256);

        float[] signal = new float[16000];
        for (int i = 0; i < signal.Length; i++)
            signal[i] = MathF.Sin(2f * MathF.PI * 440f * i / 16000f);

        // 前向 STFT
        var frames = stft.Direct(signal);
        Console.WriteLine($"Frames: {frames.Count}");

        // 谱图（功率谱列表）
        var spectrogram = stft.Spectrogram(signal);

        // 逆 STFT
        var reconstructed = stft.Inverse(frames);
        Console.WriteLine($"Reconstructed length: {reconstructed.Length}");
    }
}

FftButterflyFp32 / FftButterflyFp64（内部内核）

FftButterflyFp32 与 FftButterflyFp64 是 internal static 的结构数组（SoA）radix-2 蝶形内核，分别由 Fft / RealFft、Fft64 / RealFft64 与 FastFourierTransform.Forward / Inverse 共享。它们不属于公开 API，但此处说明它们实现了由 ComputingContext 选择的 SIMD 与并行执行路径。

每个内核暴露：

public static bool WillAccelerate(CpuExecutionMode mode, int size)
- 当给定 mode 与 size 会走加速（SIMD 或并行）路径时返回 true。低于 SIMD 交叉点（约 8K）时调用方的标量蝶形更快，内核返回 false，调用类回退到自身的标量蝶形。
public static void Transform(float[]/double[] re, float[]/double[] im, int size, bool inverse, CpuExecutionMode mode, ComputingContext? context = null)
- 就地 radix-2 蝶形各阶段，随后进行位反转置换。inverse 选择旋转因子符号。

通过 CpuExecutionMode 选择三种执行路径：标量（Normal）、Vector<T> SIMD 与并行。所有路径的结果与原始标量频率抽取 FFT 一致（仅浮点舍入差异）。

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_Fourier_zh

信号处理模块 - Signal Processing Module

傅立叶变换 - Fourier Transform

Vorcyc.Mathematics.SignalProcessing.Fourier.FastFourierTransform 类

方法

1. Forward

2. Inverse

代码示例

Vorcyc.Mathematics.SignalProcessing.Fourier.Fft 类

属性

1. Size

方法

1. Fft 构造函数

2. Direct（就地）

3. Direct（拷贝版本）

4. DirectNorm

5. Inverse（就地）

6. Inverse（拷贝版本）

7. InverseNorm

8. MagnitudeSpectrum

9. PowerSpectrum

10. Shift（静态）

代码示例

Vorcyc.Mathematics.SignalProcessing.Fourier.Fft64 类

属性

1. Size

方法

1. Fft64 构造函数

2. Direct（就地）

3. Direct（拷贝版本）

4. DirectNorm

5. Inverse（就地）

6. Inverse（拷贝版本）

7. InverseNorm

代码示例

Vorcyc.Mathematics.SignalProcessing.Fourier.Fft<T> 类

方法

Vorcyc.Mathematics.SignalProcessing.Fourier.RealFft<T> 类

方法

Vorcyc.Mathematics.SignalProcessing.Fourier.RealFft 类

属性

1. Size

方法

1. RealFft 构造函数

2. Direct

3. DirectNorm

4. Inverse

5. InverseNorm

6. MagnitudeSpectrum

7. PowerSpectrum

8. Shift（静态）

代码示例

Vorcyc.Mathematics.SignalProcessing.Fourier.RealFft64 类

属性

1. Size

方法

1. RealFft64 构造函数

2. Direct

3. DirectNorm

4. Inverse

5. InverseNorm

代码示例

Vorcyc.Mathematics.SignalProcessing.Fourier.Stft 类

属性

1. Size

方法

1. Stft 构造函数

2. Direct

3. Inverse

4. Spectrogram

5. AveragePeriodogram

6. MagnitudePhaseSpectrogram

7. ReconstructMagnitudePhase

MagnitudePhaseList 结构体

代码示例

FftButterflyFp32 / FftButterflyFp64（内部内核）

Uh oh!

Uh oh!

Uh oh!

Uh oh!