Ecosyste.ms: Awesome

An open API service indexing awesome lists of open source software.

https://github.com/vail-systems/node-fft

Pure Node.js implementation of the Fast Fourier Transform (Cooley-Tukey method).
https://github.com/vail-systems/node-fft

Last synced: 16 days ago
JSON representation

Pure Node.js implementation of the Fast Fourier Transform (Cooley-Tukey method).

Lists

README 

        
# fft-js

Pure Node.js implementation of the Fast Fourier Transform (Cooley-Tukey Method).



Note: normally inclusion of 'js' in the package name is discouraged. However many of the FFT implementations on NPM at the time this was written are wrappers for other languages like Ruby or C. We wanted to write our own, unoptimized implementation in pure Javascript as an educational tool. As a result it is called fft-js.



# Simple Example



    var fft = require('fft-js').fft,

        signal = [1,0,1,0];



    var phasors = fft(signal);



    console.log(phasors);



# Frequency/Magnitude Example



    var fft = require('fft-js').fft,

        fftUtil = require('fft-js').util,

        signal = [1,0,1,0];



    var phasors= fft(signal);



    var frequencies = fftUtil.fftFreq(phasors, 8000), // Sample rate and coef is just used for length, and frequency step

        magnitudes = fftUtil.fftMag(phasors); 



    var both = frequencies.map(function (f, ix) {

        return {frequency: f, magnitude: magnitudes[ix]};

    });



    console.log(both);



# Calculate IFFT of given phasors

    

    var ifft = require('fft-js').ifft;



    var phasors=[[1,0], [0,0], [1,0], [0,0]];



    var signal=ifft(phasors);



    console.log(signal);



#Calculate fft, modify phasors and calculate ifft



    var fft = require('fft-js').fft;

    var ifft = require('fft-js').ifft;



    var signal=[1,0,1,0];



    var phasors=fft(signal);



    console.log(phasors);



    phasors[2][0]=0;



    var signal2=ifft(phasors);



    console.log(signal2);



    

# Brute force O(n^2) DFT Example



The DFT (Discrete Fourier Transform) is an unoptimized Fourier Transform for discrete data. In this project it is primarily a teaching tool, and is used to test the FFT.



    var dft = require('fft-js').dft,

        signal = [1,0,1,0];

    

    var phasors = dft(signal);

    

    console.log(phasors);



# Calculate IDFT of given phasors

    

    var idft = require('fft-js').idft;



    var phasors=[[1,0], [0,0], [1,0], [0,0]];



    var signal=idft(phasors);



    console.log(signal);



# In-place FFT Example



The in-place FFT implementation generates the FFT in-place, overwriting the original input vector. This is useful for minimizing new memory allocations required for the recursive version.



    var fftInPlace = require('fft-js').fftInPlace,

        signal = [1, 0, 1, 0];

        

    fftInPlace(signal);

    

    console.log(signal); //We have overwritten the original vector here with the FFT output.



# Command Line



For testing, you can run from the command line. Input is assumed to be from standard input and contain

a comma-delimited list of real numbers.



Command:

    node fft.js -s 44100 test/signal8.js



Console:



    Signal:  [ 1, 1, 1, 1, 0, 0, 0, 0 ]



    FFT:  [ [ 4, 0 ],

    [ 1, -2.414213562373095 ],

    [ 0, 0 ],

    [ 1, -0.4142135623730949 ],

    [ 0, 0 ],

    [ 0.9999999999999999, 0.4142135623730949 ],

    [ 0, 0 ],

    [ 0.9999999999999997, 2.414213562373095 ] ]



    FFT Magnitudes:  [ 4, 2.613125929752753, 0, 1.0823922002923938 ] //We only see the first 4, because the 2nd 4 are the Nyquist frequency (discarded for aliasing), and then the mirror image negative frequencies.



    FFT Frequencies:  [ 0, 5512.5, 11025, 16537.5 ]



# Testing



See `test/test.js`. Using Mocha:



    mocha



Output:



      FFT (Cooley-Tukey)

        1,0,1,0

          √ Should properly compute [1,0,1,0]

        1,0,1,0,2,0,2,0

          √ Should properly compute [1,0,1,0,2,0,2,0]



      IFFT (Cooley-Tukey)

        1,0,1,0

          √ Should properly compute [1,0,1,0]

        1,0,1,0,2,0,2,0

          √ Should properly compute [1,0,1,0,2,0,2,0]



      FFT (in-place Cooley-Tukey)

        1,0,1,0

          √ Should properly compute [1,0,1,0]

        1,0,1,0,2,0,2,0

          √ Should properly compute [1,0,1,0,2,0,2,0]



      DFT O(n^2) Brute Force

        1,0,1,0

          √ Should properly compute [1, 0, 1, 0]



      IDFT O(n^2) Brute Force

        1,0,1,0

          √ Should properly compute [1, 0, 1, 0]

        1,0,1,0,2,0,2,0

          √ Should properly compute [1,0,1,0,2,0,2,0]



      Compare FFT to DFT

        randomSignal FFT

          √ Should compute randomSignal

        randomSignal in-place FFT

          √ Should compute randomSignal

        randomSignal DFT

          √ Should compute randomSignal

        randomSignal FFT and DFT

          √ Should compute same output

        randomSignal in-place FFT and DFT

          √ Should compute same output



      14 passing (27ms)



# License 



The MIT License (MIT)



Copyright (c) 2015 Vail Systems



Permission is hereby granted, free of charge, to any person obtaining a copy

of this software and associated documentation files (the "Software"), to deal

in the Software without restriction, including without limitation the rights

to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

copies of the Software, and to permit persons to whom the Software is

furnished to do so, subject to the following conditions:



The above copyright notice and this permission notice shall be included in all

copies or substantial portions of the Software.



THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

SOFTWARE.