Module_SignalProcessing_Fourier_zh - vorcyc/Vorcyc.Mathematics GitHub Wiki

当前位置 : 首页/信号处理模块/傅立叶变换

信号处理模块 - 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.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 一致（仅浮点舍入差异）。

⚠️ **GitHub.com Fallback** ⚠️