Update FFT tests.

Author: trekhleb

src/algorithms/math/fourier-transform/README.md

@@ -120,8 +120,9 @@ Stuart Riffle has a great interpretation of the Fourier Transform:
 ## References
 
 - [An Interactive Guide To The Fourier Transform](https://betterexplained.com/articles/an-interactive-guide-to-the-fourier-transform/)
-- [YouTube by Better Explained](https://www.youtube.com/watch?v=iN0VG9N2q0U&t=0s&index=77&list=PLLXdhg_r2hKA7DPDsunoDZ-Z769jWn4R8)
-- [YouTube by 3Blue1Brown](https://www.youtube.com/watch?v=spUNpyF58BY&t=0s&index=76&list=PLLXdhg_r2hKA7DPDsunoDZ-Z769jWn4R8)
+- [DFT on YouTube by Better Explained](https://www.youtube.com/watch?v=iN0VG9N2q0U&t=0s&index=77&list=PLLXdhg_r2hKA7DPDsunoDZ-Z769jWn4R8)
+- [FT on YouTube by 3Blue1Brown](https://www.youtube.com/watch?v=spUNpyF58BY&t=0s&index=76&list=PLLXdhg_r2hKA7DPDsunoDZ-Z769jWn4R8)
+- [FFT on YouTube by Simon Xu](https://www.youtube.com/watch?v=htCj9exbGo0&index=78&list=PLLXdhg_r2hKA7DPDsunoDZ-Z769jWn4R8&t=0s)
 - Wikipedia
   - [FT](https://en.wikipedia.org/wiki/Fourier_transform)
   - [DFT](https://www.wikiwand.com/en/Discrete_Fourier_transform)

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

@@ -53,10 +53,10 @@ describe('fastFourierTransform', () => {
     ];
 
     const output = fastFourierTransform(input);
-    const invertedOut = fastFourierTransform(output, true);
+    const invertedOutput = fastFourierTransform(output, true);
 
     expect(sequencesApproximatelyEqual(expectedOutput, output, delta)).toBe(true);
-    expect(sequencesApproximatelyEqual(input, invertedOut, delta)).toBe(true);
+    expect(sequencesApproximatelyEqual(input, invertedOutput, delta)).toBe(true);
   });
 
   it('should calculate the radix-2 discrete fourier transform #3', () => {

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

@@ -4,17 +4,17 @@ import bitLength from '../bits/bitLength';
 /**
  * Returns the number which is the flipped binary representation of input.
  *
- * @param {Number} [input]
- * @param {Number} [bitsCount]
- * @return {Number}
+ * @param {number} input
+ * @param {number} bitsCount
+ * @return {number}
  */
 function reverseBits(input, bitsCount) {
   let reversedBits = 0;
 
-  for (let i = 0; i < bitsCount; i += 1) {
+  for (let bitIndex = 0; bitIndex < bitsCount; bitIndex += 1) {
     reversedBits *= 2;
 
-    if (Math.floor(input / (1 << i)) % 2 === 1) {
+    if (Math.floor(input / (1 << bitIndex)) % 2 === 1) {
       reversedBits += 1;
     }
   }
@@ -39,8 +39,8 @@ export default function fastFourierTransform(inputData, inverse = false) {
   }
 
   const output = [];
-  for (let i = 0; i < N; i += 1) {
-    output[i] = inputData[reverseBits(i, bitsCount)];
+  for (let dataSampleIndex = 0; dataSampleIndex < N; dataSampleIndex += 1) {
+    output[dataSampleIndex] = inputData[reverseBits(dataSampleIndex, bitsCount)];
   }
 
   for (let blockLength = 2; blockLength <= N; blockLength *= 2) {
@@ -53,23 +53,23 @@ export default function fastFourierTransform(inputData, inverse = false) {
     for (let blockStart = 0; blockStart < N; blockStart += blockLength) {
       let phase = new ComplexNumber({ re: 1, im: 0 });
 
-      for (let idx = blockStart; idx < blockStart + blockLength / 2; idx += 1) {
-        const component = output[idx + blockLength / 2].multiply(phase);
+      for (let signalId = blockStart; signalId < (blockStart + blockLength / 2); signalId += 1) {
+        const component = output[signalId + blockLength / 2].multiply(phase);
 
-        const upd1 = output[idx].add(component);
-        const upd2 = output[idx].subtract(component);
+        const upd1 = output[signalId].add(component);
+        const upd2 = output[signalId].subtract(component);
 
-        output[idx] = upd1;
-        output[idx + blockLength / 2] = upd2;
+        output[signalId] = upd1;
+        output[signalId + blockLength / 2] = upd2;
 
         phase = phase.multiply(phaseStep);
       }
     }
   }
 
   if (inverse) {
-    for (let idx = 0; idx < N; idx += 1) {
-      output[idx] /= N;
+    for (let signalId = 0; signalId < N; signalId += 1) {
+      output[signalId] /= N;
     }
   }