Style fixes for FFT code.

Author: trekhleb

src/algorithms/math/fourier-transform/__test__/fastFourierTransform.test.js

@@ -2,50 +2,65 @@ import fastFourierTransform from '../fastFourierTransform';
 import ComplexNumber from '../../complex-number/ComplexNumber';
 
 /**
- * @param {ComplexNumber[]} [seq1]
- * @param {ComplexNumber[]} [seq2]
- * @param {Number} [eps]
+ * @param {ComplexNumber[]} sequence1
+ * @param {ComplexNumber[]} sequence2
+ * @param {Number} delta
  * @return {boolean}
  */
-function approximatelyEqual(seq1, seq2, eps) {
- if (seq1.length !== seq2.length) { return false; }
+function sequencesApproximatelyEqual(sequence1, sequence2, delta) {
+ if (sequence1.length !== sequence2.length) {
+ return false;
+ }
+
+ for (let numberIndex = 0; numberIndex < sequence1.length; numberIndex += 1) {
+ if (Math.abs(sequence1[numberIndex].re - sequence2[numberIndex].re) > delta) {
+ return false;
+ }
 
- for (let i = 0; i < seq1.length; i += 1) {
- if (Math.abs(seq1[i].real - seq2[i].real) > eps) { return false; }
- if (Math.abs(seq1[i].complex - seq2[i].complex) > eps) { return false; }
+  if (Math.abs(sequence1[numberIndex].im - sequence2[numberIndex].im) > delta) {
+  return false;
+ }
  }
 
  return true;
 }
 
+const delta = 1e-6;
+
 describe('fastFourierTransform', () => {
  it('should calculate the radix-2 discrete fourier transform after zero padding', () => {
- const eps = 1e-6;
- const in1 = [new ComplexNumber({ re: 0, im: 0 })];
- const expOut1 = [new ComplexNumber({ re: 0, im: 0 })];
- const out1 = fastFourierTransform(in1);
- const invOut1 = fastFourierTransform(out1, true);
- expect(approximatelyEqual(expOut1, out1, eps)).toBe(true);
- expect(approximatelyEqual(in1, invOut1, eps)).toBe(true);
+ const input = [new ComplexNumber({ re: 0, im: 0 })];
+ const expectedOutput = [new ComplexNumber({ re: 0, im: 0 })];
+ const output = fastFourierTransform(input);
+ const invertedOutput = fastFourierTransform(output, true);
 
- const in2 = [
+ expect(sequencesApproximatelyEqual(expectedOutput, output, delta)).toBe(true);
+ expect(sequencesApproximatelyEqual(input, invertedOutput, delta)).toBe(true);
+ });
+
+ it('should calculate the radix-2 discrete fourier transform after zero padding', () => {
+ const input = [
  new ComplexNumber({ re: 1, im: 2 }),
  new ComplexNumber({ re: 2, im: 3 }),
  new ComplexNumber({ re: 8, im: 4 }),
  ];
 
- const expOut2 = [
+ const expectedOutput = [
  new ComplexNumber({ re: 11, im: 9 }),
  new ComplexNumber({ re: -10, im: 0 }),
  new ComplexNumber({ re: 7, im: 3 }),
  new ComplexNumber({ re: -4, im: -4 }),
  ];
- const out2 = fastFourierTransform(in2);
- const invOut2 = fastFourierTransform(out2, true);
- expect(approximatelyEqual(expOut2, out2, eps)).toBe(true);
- expect(approximatelyEqual(in2, invOut2, eps)).toBe(true);
 
- const in3 = [
+ const output = fastFourierTransform(input);
+ const invertedOut = fastFourierTransform(output, true);
+
+ expect(sequencesApproximatelyEqual(expectedOutput, output, delta)).toBe(true);
+ expect(sequencesApproximatelyEqual(input, invertedOut, delta)).toBe(true);
+ });
+
+ it('should calculate the radix-2 discrete fourier transform after zero padding', () => {
+ const input = [
  new ComplexNumber({ re: -83656.9359385182, im: 98724.08038374918 }),
  new ComplexNumber({ re: -47537.415125808424, im: 88441.58381765135 }),
  new ComplexNumber({ re: -24849.657029355192, im: -72621.79007878687 }),
@@ -58,7 +73,7 @@ describe('fastFourierTransform', () => {
  new ComplexNumber({ re: -39327.43830818355, im: 30611.949874562706 }),
  ];
 
- const expOut3 = [
+ const expectedOutput = [
  new ComplexNumber({ re: -203215.3322151, im: -100242.4827503 }),
  new ComplexNumber({ re: 99217.0805705, im: 270646.9331932 }),
  new ComplexNumber({ re: -305990.9040412, im: 68224.8435751 }),
@@ -77,9 +92,10 @@ describe('fastFourierTransform', () => {
  new ComplexNumber({ re: -179002.5662573, im: 239821.0124341 }),
  ];
 
- const out3 = fastFourierTransform(in3);
- const invOut3 = fastFourierTransform(out3, true);
- expect(approximatelyEqual(expOut3, out3, eps)).toBe(true);
- expect(approximatelyEqual(in3, invOut3, eps)).toBe(true);
+ const output = fastFourierTransform(input);
+ const invertedOutput = fastFourierTransform(output, true);
+
+ expect(sequencesApproximatelyEqual(expectedOutput, output, delta)).toBe(true);
+ expect(sequencesApproximatelyEqual(input, invertedOutput, delta)).toBe(true);
  });
 });

src/algorithms/math/fourier-transform/fastFourierTransform.js

@@ -10,68 +10,66 @@ import bitLength from '../bits/bitLength';
  */
 function reverseBits(input, bitsCount) {
  let reversedBits = 0;
+
  for (let i = 0; i < bitsCount; i += 1) {
  reversedBits *= 2;
- if (Math.floor(input / (1 << i)) % 2 === 1) { reversedBits += 1; }
+
+ if (Math.floor(input / (1 << i)) % 2 === 1) {
+ reversedBits += 1;
+ }
  }
+
  return reversedBits;
 }
 
 /**
  * Returns the radix-2 fast fourier transform of the given array.
  * Optionally computes the radix-2 inverse fast fourier transform.
  *
- * @param {ComplexNumber[]} [inputData]
- * @param {Boolean} [inverse]
+ * @param {ComplexNumber[]} inputData
+ * @param {boolean} [inverse]
  * @return {ComplexNumber[]}
  */
 export default function fastFourierTransform(inputData, inverse = false) {
  const bitsCount = bitLength(inputData.length - 1);
  const N = 1 << bitsCount;
 
  while (inputData.length < N) {
- inputData.push(new ComplexNumber({
- real: 0,
- imaginary: 0,
- }));
+ inputData.push(new ComplexNumber());
  }
 
  const output = [];
- for (let i = 0; i < N; i += 1) { output[i] = inputData[reverseBits(i, bitsCount)]; }
+ for (let i = 0; i < N; i += 1) {
+ output[i] = inputData[reverseBits(i, bitsCount)];
+ }
 
  for (let blockLength = 2; blockLength <= N; blockLength *= 2) {
- let phaseStep;
- if (inverse) {
- phaseStep = new ComplexNumber({
- real: Math.cos(2 * Math.PI / blockLength),
- imaginary: -1 * Math.sin(2 * Math.PI / blockLength),
- });
- } else {
- phaseStep = new ComplexNumber({
- real: Math.cos(2 * Math.PI / blockLength),
- imaginary: Math.sin(2 * Math.PI / blockLength),
- });
- }
+ const imaginarySign = inverse ? -1 : 1;
+ const phaseStep = new ComplexNumber({
+ re: Math.cos(2 * Math.PI / blockLength),
+ im: imaginarySign * Math.sin(2 * Math.PI / blockLength),
+ });
 
  for (let blockStart = 0; blockStart < N; blockStart += blockLength) {
- let phase = new ComplexNumber({
- real: 1,
- imaginary: 0,
- });
+ let phase = new ComplexNumber({ re: 1, im: 0 });
 
  for (let idx = blockStart; idx < blockStart + blockLength / 2; idx += 1) {
  const upd1 = output[idx].add(output[idx + blockLength / 2].multiply(phase));
  const upd2 = output[idx].subtract(output[idx + blockLength / 2].multiply(phase));
+
  output[idx] = upd1;
  output[idx + blockLength / 2] = upd2;
+
  phase = phase.multiply(phaseStep);
  }
  }
  }
+
  if (inverse) {
  for (let idx = 0; idx < N; idx += 1) {
  output[idx] /= N;
  }
  }
+
  return output;
 }