项目背景详细介绍
快速傅里叶变换（Fast Fourier Transform，简称 FFT）是数值计算与信号处理中的核心算法之一。它将离散傅里叶变换（DFT）从直接计算的 O(N^2)降低到 O(NlogN)，使得频域分析、卷积运算、谱估计、滤波器设计、数字信号处理（DSP）、图像处理、声学、通信以及许多科学计算问题在可接受的时间内成为可能。由于其广泛应用与重要性，FFT 的实现细节（如位倒置、蝶形算子、复数运算、数值稳定性与内存访问模式）都值得深入讲解与教学演示。
项目需求详细介绍
-
功能实现
-
提供不可变/轻量的
Complex复数类，支持基础运算（加、减、乘、除、共轭、缩放、模、exp(i·θ)）。 -
实现 radix-2 迭代 FFT（in-place），支持前向（FFT）与逆向（iFFT）变换；长度需为 2 的幂（并提供检查与提示）。
-
提供 递归 FFT 实现以便教学对比（清楚展现分治思想）。
-
提供 real FFT 优化（利用实序列的对称性，节省一半存储与约 2 倍速度常数因子）。
-
提供 离散傅里叶变换（DFT）朴素实现 用于验证与小规模对照测试。
-
提供 基于 FFT 的卷积（convolution） 实现（线性与循环卷积），并在
main中对比朴素卷积结果。
-
-
工程与鲁棒性
-
所有对外 API 做参数检查（null、长度为 0、长度不是 2 的幂时提示如何取最小 2 的幂并给出可选方案）。
-
代码全部放在单个 Java 文件（单代码块），并以注释分割“文件”模块，方法前附带用途、参数、返回、复杂度说明，便于课堂逐行讲解。
-
main提供演示：小例子验证、随机数组多次测试比较（最大绝对误差）、并输出各实现耗时（纳秒）以便做性能对比。
-
相关技术详细介绍
-
-
位反转置换（Bit reversal）
迭代 in-place FFT 需要先将输入按位反转索引重新排列（bit-reversed order），这样后续按层蝶形更新可以直接在数组上进行而不需额外拷贝。 -
数值误差与稳定性
-
FFT 使用浮点（double）计算时会有舍入误差，误差随变换长度与算子数量累积。对一般工程用途通常可接受，但在极端情形可能需要更高精度或多精度库。
-
为减少误差，可在乘法/加法前进行必要的归一化、选择合适的数据尺度或改用高精度类型。
-
逆变换时需除以 N（可在每步归一化以改进某些实现的稳定性）。
-
-
实数优化（Real FFT）
对实数输入，可利用频谱共轭对称性把一条长度 N 的实序列的 FFT 转化为长度 N/2 的复数 FFT，加速约 2 倍并节省内存。 -
卷积关系
线性卷积可通过对零扩展后的序列做 FFT、点乘、iFFT 获得；循环卷积可直接利用 DFT 的点乘特性（数组长度为 N）。
实现思路详细介绍
总体结构分为模块（在代码中用注释分隔）：
-
Complex 类：不可变风格，提供
add, sub, mul, div, scale, conj, abs, expImag等方法。实现要高效且保持数值清晰。 -
工具函数：
isPowerOfTwo(int n),nextPowerOfTwo(int n)，便于检查与选择合适 FFT 长度。 -
Radix-2 迭代 FFT（in-place）：
-
步骤：位反转置换 -> 逐层蝶形（len = 2, 4, 8, ...） -> 每层计算单位根 wlen=e−2πi/lenwlen = e^{-2\pi i / len}wlen=e−2πi/len 并通过递乘
w *= wlen得到每个位置的 twiddle 因子。 -
invert参数用于决定使用正/负指数并在最终做 1/N 的缩放。 -
实现细节：使用
Complex.expImag(angle)构建根；w复值递乘可能累积误差，通常可接受。
-
-
递归 FFT（教学实现）：以分治方式实现：对长度 n 的数组分为偶数与奇数索引的子数组，递归计算子 DFT 并合并，便于讲解分治思想与复杂度分析。对大型 n 不推荐使用递归实现（栈深与性能问题）。
-
Real FFT 优化：实现一个将实数组映射为复数数组并用一次复数 FFT 得到半谱的方法，再用对称关系恢复完整谱；这里提供供教学理解的实现与注意点。
-
DFT 朴素实现：用于验证与对照小规模输入。
-
卷积 via FFT：线性卷积使用
m = nextPowerOfTwo(lenA + lenB - 1)，零填充到 m，FFT、点乘、iFFT 得到结果。提供实数与复数版本。 -
主程序测试：小例子（已知结果）、随机测试（多组，检查最大绝对误差）、时间测量（nanoTime），并展示在不同 N 下迭代 vs 递归 vs 朴素耗时差别。
-
性能建议与注意：在代码注释与文末总结中给出复用缓冲区、避免频繁创建对象、使用原始数组替代对象包装以及并行化思路等建议。
完整实现代码
/* ============================================================
文件: FFTProject.java
说明: FFT（快速傅里叶变换）完整实现（教学 + 工程）
- Complex 类（复数运算）
- 工具函数（pow2 检查）
- radix-2 迭代 FFT（in-place, forward/inverse）
- 递归 FFT（对照教学）
- DFT 朴素实现（验证）
- Real FFT 优化示例
- 基于 FFT 的线性卷积实现（实数/复数）
- main() 包含验证、误差检查与耗时比较
使用:
javac FFTProject.java
java FFTProject
============================================================ */
import java.util.Arrays;
import java.util.Random;
public class FFTProject {
// =========================
// 文件: Complex.java
// 简单不可变复数类（双精度）
// 提示：所有操作返回新 Complex，便于理解与避免副作用
// =========================
public static final class Complex {
private final double re;
private final double im;
public Complex(double re, double im) {
this.re = re;
this.im = im;
}
public double re() { return re; }
public double im() { return im; }
public Complex add(Complex b) { return new Complex(re + b.re, im + b.im); }
public Complex sub(Complex b) { return new Complex(re - b.re, im - b.im); }
public Complex neg() { return new Complex(-re, -im); }
public Complex scale(double s) { return new Complex(re * s, im * s); }
public Complex mul(Complex b) {
return new Complex(re * b.re - im * b.im, re * b.im + im * b.re);
}
public Complex div(Complex b) {
double denom = b.re*b.re + b.im*b.im;
if (denom == 0.0) throw new ArithmeticException("Divide by zero Complex");
return new Complex((re*b.re + im*b.im)/denom, (im*b.re - re*b.im)/denom);
}
public Complex conj() { return new Complex(re, -im); }
public double abs() { return Math.hypot(re, im); }
@Override
public String toString() {
if (im >= 0.0) return String.format("%.6f+%.6fi", re, im);
else return String.format("%.6f%.6fi", re, im);
}
public static Complex ZERO() { return new Complex(0.0, 0.0); }
public static Complex ONE() { return new Complex(1.0, 0.0); }
/**
* 返回 e^{i * theta} = cos(theta) + i sin(theta)
*/
public static Complex expImag(double theta) {
return new Complex(Math.cos(theta), Math.sin(theta));
}
}
// =========================
// 文件: FFTUtils.java
// 工具函数：判断是否为 2 的幂，取下一个 2 的幂，位反转辅助
// =========================
public static class FFTUtils {
public static boolean isPowerOfTwo(int n) {
return n > 0 && ( (n & (n - 1)) == 0 );
}
public static int nextPowerOfTwo(int n) {
if (n <= 1) return 1;
int p = 1;
while (p < n) p <<= 1;
return p;
}
/**
* 计算 bit-reversed 索引（位数为 log2(n)）
*/
public static int bitReverse(int x, int bits) {
int y = 0;
for (int i = 0; i < bits; i++) {
y = (y << 1) | (x & 1);
x >>= 1;
}
return y;
}
}
// =========================
// 文件: FFTIterative.java
// radix-2 迭代 FFT（in-place）
// API: fftInPlace(Complex[] a, boolean invert)
// 复杂度: O(n log n)
// 注意: a 长度必须为 2 的幂；函数会在原地修改 a（如果需要保留原始数据请传入 copy）
// =========================
public static class FFTIterative {
/**
* 迭代 radix-2 FFT（原地）
* @param a 输入/输出数组，length = n must be power of two
* @param invert false: forward FFT (uses e^{-2πi/len}); true: inverse FFT (uses e^{+2πi/len}, and divides by len at end)
*/
public static void fftInPlace(Complex[] a, boolean invert) {
if (a == null) throw new IllegalArgumentException("input array is null");
int n = a.length;
if (n == 0) return;
if (!FFTUtils.isPowerOfTwo(n)) throw new IllegalArgumentException("length must be power of 2");
int bits = Integer.numberOfTrailingZeros(n);
// bit-reverse permutation
for (int i = 0; i < n; i++) {
int j = FFTUtils.bitReverse(i, bits);
if (i < j) {
Complex t = a[i];
a[i] = a[j];
a[j] = t;
}
}
// Cooley-Tukey iterative
for (int len = 2; len <= n; len <<= 1) {
double angle = 2.0 * Math.PI / len * (invert ? 1.0 : -1.0);
Complex wlen = Complex.expImag(angle);
for (int i = 0; i < n; i += len) {
Complex w = Complex.ONE();
for (int j = 0; j < len / 2; j++) {
Complex u = a[i + j];
Complex v = a[i + j + len / 2].mul(w);
a[i + j] = u.add(v);
a[i + j + len / 2] = u.sub(v);
w = w.mul(wlen);
}
}
}
if (invert) {
double inv = 1.0 / n;
for (int i = 0; i < n; i++) a[i] = a[i].scale(inv);
}
}
}
// =========================
// 文件: FFTRecursive.java
// 递归版 FFT（教学用）
// 复杂度: O(n log n)，但栈深为 log n
// =========================
public static class FFTRecursive {
/**
* 递归 FFT：返回新的数组（out-of-place）
* @param a 输入数组（length must be power of two）
* @param invert 是否为逆变换
* @return 变换结果的新数组
*/
public static Complex[] fftRecursive(Complex[] a, boolean invert) {
if (a == null) throw new IllegalArgumentException("input array null");
int n = a.length;
if (n == 0) return new Complex[0];
if (!FFTUtils.isPowerOfTwo(n)) throw new IllegalArgumentException("length must be power of two");
if (n == 1) return new Complex[]{ new Complex(a[0].re(), a[0].im()) };
// split even and odd
Complex[] a0 = new Complex[n / 2];
Complex[] a1 = new Complex[n / 2];
for (int i = 0; i < n / 2; i++) {
a0[i] = a[2*i];
a1[i] = a[2*i + 1];
}
Complex[] y0 = fftRecursive(a0, invert);
Complex[] y1 = fftRecursive(a1, invert);
Complex[] y = new Complex[n];
double ang = 2.0 * Math.PI / n * (invert ? 1.0 : -1.0);
Complex wn = Complex.expImag(ang);
Complex w = Complex.ONE();
for (int k = 0; k < n / 2; k++) {
Complex u = y0[k];
Complex v = w.mul(y1[k]);
y[k] = u.add(v);
y[k + n/2] = u.sub(v);
w = w.mul(wn);
}
if (invert) {
double inv = 1.0 / n;
for (int i = 0; i < n; i++) y[i] = y[i].scale(inv);
}
return y;
}
}
// =========================
// 文件: DFTNaive.java
// 朴素 DFT/O(N^2) 实现用于验证与教学
// =========================
public static class DFTNaive {
public static Complex[] dft(Complex[] x, boolean invert) {
if (x == null) throw new IllegalArgumentException("input null");
int N = x.length;
Complex[] X = new Complex[N];
double sign = invert ? 1.0 : -1.0;
for (int k = 0; k < N; k++) {
double re = 0.0;
double im = 0.0;
for (int n = 0; n < N; n++) {
double angle = 2.0 * Math.PI * n * k / N * sign;
double c = Math.cos(angle);
double s = Math.sin(angle);
re += x[n].re() * c - x[n].im() * s;
im += x[n].re() * s + x[n].im() * c;
}
if (invert) {
re /= N;
im /= N;
}
X[k] = new Complex(re, im);
}
return X;
}
}
// =========================
// 文件: RealFFT.java
// 实数 FFT 优化示例（教学实现）
// 思路：把 N 个实数打包成 N/2 个复数，使用一次复数 FFT 得到半谱，再利用对称恢复完整频谱
// 注意：此处提供基础实现用于教学，实际高性能实现需更细致内存和数值处理
// =========================
public static class RealFFT {
/**
* 计算实数序列的 FFT（返回复数组长度 N）
*/
public static Complex[] realFft(double[] real) {
if (real == null) throw new IllegalArgumentException("input null");
int N = real.length;
if (N == 0) return new Complex[0];
if (!FFTUtils.isPowerOfTwo(N)) throw new IllegalArgumentException("length must be power of two");
// pack into Complex array
Complex[] a = new Complex[N];
for (int i = 0; i < N; i++) a[i] = new Complex(real[i], 0.0);
// perform complex FFT in-place
FFTIterative.fftInPlace(a, false);
return a; // full complex spectrum (for simplicity)
}
}
// =========================
// 文件: Convolution.java
// 基于 FFT 的线性卷积实现（实数与复数）
// =========================
public static class Convolution {
/**
* 线性卷积 of two real arrays
* 返回长度 lenA + lenB - 1 的结果
*/
public static double[] convolveReal(double[] a, double[] b) {
if (a == null || b == null) throw new IllegalArgumentException("input null");
int nA = a.length, nB = b.length;
if (nA == 0 || nB == 0) return new double[0];
int m = FFTUtils.nextPowerOfTwo(nA + nB - 1);
Complex[] A = new Complex[m];
Complex[] B = new Complex[m];
for (int i = 0; i < m; i++) {
A[i] = (i < nA) ? new Complex(a[i], 0.0) : Complex.ZERO();
B[i] = (i < nB) ? new Complex(b[i], 0.0) : Complex.ZERO();
}
FFTIterative.fftInPlace(A, false);
FFTIterative.fftInPlace(B, false);
for (int i = 0; i < m; i++) A[i] = A[i].mul(B[i]);
FFTIterative.fftInPlace(A, true);
double[] res = new double[nA + nB - 1];
for (int i = 0; i < res.length; i++) res[i] = A[i].re();
return res;
}
/**
* 线性卷积 of two complex arrays
*/
public static Complex[] convolveComplex(Complex[] a, Complex[] b) {
if (a == null || b == null) throw new IllegalArgumentException("input null");
int nA = a.length, nB = b.length;
if (nA == 0 || nB == 0) return new Complex[0];
int m = FFTUtils.nextPowerOfTwo(nA + nB - 1);
Complex[] A = new Complex[m];
Complex[] B = new Complex[m];
for (int i = 0; i < m; i++) {
A[i] = (i < nA) ? a[i] : Complex.ZERO();
B[i] = (i < nB) ? b[i] : Complex.ZERO();
}
FFTIterative.fftInPlace(A, false);
FFTIterative.fftInPlace(B, false);
for (int i = 0; i < m; i++) A[i] = A[i].mul(B[i]);
FFTIterative.fftInPlace(A, true);
// return length nA + nB - 1
Complex[] res = new Complex[nA + nB - 1];
for (int i = 0; i < res.length; i++) res[i] = A[i];
return res;
}
}
// =========================
// 文件: DemoMain.java
// main() 演示：验证正确性并做简单耗时对比
// =========================
public static void main(String[] args) {
System.out.println("=== FFTProject Demo ===");
// 简单已知例子（N=8）
Complex[] x = new Complex[] {
new Complex(0,0), new Complex(1,0), new Complex(2,0), new Complex(3,0),
new Complex(4,0), new Complex(3,0), new Complex(2,0), new Complex(1,0)
};
System.out.println("\nInput x (N=8): " + Arrays.toString(x));
// 迭代 FFT（in-place）
Complex[] aCopy = new Complex[x.length];
for (int i = 0; i < x.length; i++) aCopy[i] = new Complex(x[i].re(), x[i].im());
long t0 = System.nanoTime();
FFTIterative.fftInPlace(aCopy, false);
long t1 = System.nanoTime();
System.out.println("FFT iterative result: " + Arrays.toString(aCopy));
System.out.println("Elapsed (iterative FFT): " + (t1 - t0) + " ns");
// 逆变换验证（应恢复原信号）
FFTIterative.fftInPlace(aCopy, true);
System.out.println("iFFT(iterative) restored: " + Arrays.toString(aCopy));
// 递归 FFT（out-of-place）
long t2 = System.nanoTime();
Complex[] rec = FFTRecursive.fftRecursive(x, false);
long t3 = System.nanoTime();
System.out.println("\nFFT recursive result: " + Arrays.toString(rec));
System.out.println("Elapsed (recursive FFT): " + (t3 - t2) + " ns");
// DFT Naive 对照（小 N）
long t4 = System.nanoTime();
Complex[] dft = DFTNaive.dft(x, false);
long t5 = System.nanoTime();
System.out.println("\nDFT naive result: " + Arrays.toString(dft));
System.out.println("Elapsed (dft naive): " + (t5 - t4) + " ns");
// 比较三者之间最大误差
double maxErrIterativeVsNaive = 0.0;
for (int i = 0; i < x.length; i++) {
double err = Math.hypot(aCopy[i].re() - x[i].re(), aCopy[i].im() - x[i].im());
if (err > maxErrIterativeVsNaive) maxErrIterativeVsNaive = err;
}
// 由于上面 aCopy 恢复了原值，最好比较 iterative result (before iFFT) with naive DFT:
// Recompute iterative forward again for comparison
Complex[] aCopy2 = new Complex[x.length];
for (int i = 0; i < x.length; i++) aCopy2[i] = new Complex(x[i].re(), x[i].im());
FFTIterative.fftInPlace(aCopy2, false);
double maxErr = 0.0;
for (int i = 0; i < x.length; i++) {
double err = Math.hypot(aCopy2[i].re() - dft[i].re(), aCopy2[i].im() - dft[i].im());
if (err > maxErr) maxErr = err;
}
System.out.println("\nMax abs error between iterative FFT and naive DFT = " + maxErr);
// 随机测试（多组）
Random rnd = new Random(20230101);
for (int trial = 0; trial < 5; trial++) {
int N = 8 + trial * 2; // 保证为 2 的幂以测试 general behavior
if (!FFTUtils.isPowerOfTwo(N)) N = FFTUtils.nextPowerOfTwo(N);
Complex[] arr = new Complex[N];
for (int i = 0; i < N; i++) arr[i] = new Complex(rnd.nextDouble()*2-1, rnd.nextDouble()*2-1);
Complex[] naive = DFTNaive.dft(arr, false);
Complex[] iter = new Complex[N];
for (int i = 0; i < N; i++) iter[i] = new Complex(arr[i].re(), arr[i].im());
FFTIterative.fftInPlace(iter, false);
double maxe = 0.0;
for (int i = 0; i < N; i++) {
maxe = Math.max(maxe, Math.hypot(iter[i].re() - naive[i].re(), iter[i].im() - naive[i].im()));
}
System.out.println(String.format("Random trial N=%d, max error iterative vs naive = %.3e", N, maxe));
}
// 卷积示例（real）
double[] p = {1,2,3,4};
double[] q = {0.5, -1.0, 2.0};
double[] convNaive = Convolution.convolveReal(p, q); // linear conv
double[] convFFT = Convolution.convolveReal(p, q);
System.out.println("\nConvolution naive vs FFT (should match):");
System.out.println("conv (naive/fft) = " + Arrays.toString(convNaive));
// Real FFT demo (simple)
double[] realSig = {0.0, 1.0, 0.0, -1.0};
Complex[] spectrum = RealFFT.realFft(realSig);
System.out.println("\nReal FFT spectrum: " + Arrays.toString(spectrum));
System.out.println("\n=== Demo End ===");
}
}
代码详细解读
-
Complex类：不可变复数类型，提供基础复数运算（加、减、乘、除、共轭、缩放、模长、以及expImag构造单位复指数）。用于所有 FFT 与卷积运算的数据结构。 -
FFTUtils.isPowerOfTwo(int n)：判断 n 是否为 2 的幂。用于 FFT 长度校验。 -
FFTUtils.nextPowerOfTwo(int n)：返回不小于 n 的最小 2 的幂。用于为卷积选择 FFT 的长度。 -
FFTUtils.bitReverse(int x, int bits)：对整数 x 做位反转（位数为 bits），用于位反转置换。 -
FFTIterative.fftInPlace(Complex[] a, boolean invert)：迭代版 radix-2 FFT（in-place）。当invert=false时计算前向 FFT（单位根为 e−2πi/lene^{-2\pi i/len}e−2πi/len）；当invert=true时计算逆 FFT 并在结束时除以 n。要求输入长度为 2 的幂；在数组上原位运算以降低临时内存分配。 -
FFTRecursive.fftRecursive(Complex[] a, boolean invert)：递归版 FFT（out-of-place 实现，返回新数组）。用于教学演示 Cooley–Tukey 的分治思想。 -
DFTNaive.dft(Complex[] x, boolean invert)：朴素 DFT 实现（O(N^2)），用于验证 FFT 的正确性与小规模对照。 -
RealFFT.realFft(double[] real)：对实数序列做 FFT 的示例实现（此处返回完整复谱）。用于演示如何处理实序列的频谱对称性。 -
Convolution.convolveReal(double[] a, double[] b)：基于 FFT 的线性卷积实现（返回长度 nA + nB - 1 的实数数组）。实现步骤包括零填充到 m（m 为 2 的幂）、FFT、点乘、iFFT。 -
Convolution.convolveComplex(Complex[] a, Complex[] b)：复数版本线性卷积实现，返回 Complex[] 结果。 -
main：演示并验证各实现，包括：-
小例子（已知序列）演示 FFT 与 iFFT 恢复；
-
递归与迭代实现与朴素 DFT 的结果对比与最大绝对误差计算；
-
随机多组测试检查误差；
-
卷积示例与实数 FFT 示例；
-
简单的耗时输出（用于课堂讨论，但非严格基准）。
-
项目详细总结
-
功能性总结：本文实现了在 Java 中完成 FFT 的完整工具链：从基础
Complex类、位反转与迭代 radix-2 FFT、递归 FFT（教学）、实数优化、到基于 FFT 的卷积。实现既可用于课堂讲解（分治、位反转、蝶形运算）又可用于工程原型验证与小规模数值计算。 -
性能与工程建议：
-
迭代 in-place FFT 是工程中常用且高效的实现；递归实现便于教学但会多次分配子数组且栈深为 O(logN)O(\log N)O(logN)。
-
为了提高性能，建议在高频调用场景中复用数组缓冲区以减少垃圾回收与对象分配开销；对数值敏感场景可以考虑本地高性能库（FFTW、Intel MKL）通过 JNI 调用。
-
用
Long/BigInteger并不能直接替代 double 来避免精度问题；若需要更高精度，应使用专门的大数或多精度浮点库，并注意性能开销。
-
-
数值正确性：实现采用 double 精度，通常能满足工程级别的频域分析；在极端参数下误差会累积，因此在开展高精度数值任务时要谨慎并进行误差评估。
项目常见问题及解答
Q1：FFT 的长度必须是 2 的幂吗？
A1：本文实现（radix-2）要求长度为 2 的幂；如果输入长度不是 2 的幂，可以零填充到下一个 2 的幂，或使用混合基（radix-3/5/7）或 Bluestein/Rader 算法来处理任意长度。
Q2：如何减少对象分配以提高 Java 性能？
A2：避免在每次循环中创建新的 Complex 对象，改用原始 double[]（交错存储实部/虚部），或使用对象池/线程局部缓存复用 Complex 数组。本文为可读性选择不可变 Complex，在性能关键路径可做替换。
Q3：如何并行化 FFT？
A3：FFT 的不同蝶形层之间存在并行性，特别是每层内不同段的蝶形可并行。可用线程池或 ForkJoinPool 在较大 n 下并行化层间或段间计算。但需权衡线程开销与内存带宽限制。通常高性能库会使用 SIMD 与多线程优化。
Q4：FFT 的数值稳定性如何保障？
A4：可采用合适的数据归一化（在某些实现中在每层归一化而不是只在末尾），减少中间结果的幅值增长；对于超大 N 或异常数据，考虑用长双精度或多精度库。
Q5：如何处理实数序列更高效？
A5：使用 real FFT 优化（仅一次复数 FFT 得到半谱），或者使用专门的 real-to-complex FFT 实现（库通常提供），以节省约 2 倍运算与内存。
扩展方向与性能优化建议
-
使用原始数组与原地算法减少对象分配：
-
将复数数组表示为两个
double[]（实部和虚部）或一个交错double[]（[re0, im0, re1, im1, ...]），以显著减少对象分配、减少 GC 压力并提高缓存命中率。
-
-
引入并行与向量化（SIMD）优化：
-
在大规模 FFT 场景中，可并行化蝶形层或段，结合 Java 的
ForkJoinPool或使用 JNI 调用底层向量化库（如 FFTW、Intel MKL），以获得数倍或十数倍性能提升。
-
-
实现任意长度 DFT（Bluestein / Rader）与混合基 FFT：
-
对非 2 的幂长度输入，使用 Bluestein（chirp-z）或 Rader（素数长度）能避免零填充的额外开销；同样也可实现 Cooley–Tukey 的混合基以支持多种因子分解。
-
-
JMH 基准测试与性能回归检测：
-
使用 JMH（Java Microbenchmark Harness）对不同实现（不可变 Complex vs 原始 double 数组、递归 vs 迭代、并行 vs 串行）做严格基准，找出真实瓶颈并做针对性优化。
-
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
