Filename: fft.hs
Created by: Daniel Winograd-Cort
Created on: unknown
Last Modified by: Daniel Winograd-Cort
Last Modified on: 16-Dec-2015 by Donya Quick

This module requires the array and pure-fft packages.

> {-# LANGUAGE Arrows #-}
> module HSoM.Examples.FFT where
> import FRP.UISF
> import Control.Arrow.Operations
> import Numeric.FFT (fft)
> import Data.Complex
> import Data.Map (Map)
> import qualified Data.Map as Map



Alternative for working with Math.FFT instead of Numeric.FFT
import qualified Math.FFT as FFT
import Data.Array.IArray
import Data.Array.CArray
myFFT n lst = elems $ (FFT.dft) (listArray (0, n-1) lst)


--------------------------------------
-- Fast Fourier Transform
--------------------------------------

Returns n samples of type b from the input stream at a time, 
updating after k samples.  This function is good for chunking 
data and is a critical component to fftA

> quantize :: ArrowCircuit a => Int -> Int -> a b (SEvent [b])
> quantize n k = proc d -> do
>     rec (ds,c) <- delay ([],0) -< (take n (d:ds), c+1)
>     returnA -< if c >= n && c `mod` k == 0 then Just ds else Nothing

Converts the vector result of a dft into a map from frequency to magnitude.
One common use is:
fftA >>> arr (fmap $ presentFFT clockRate)

> presentFFT :: Double -> [Double] -> Map Double Double
> presentFFT clockRate a = Map.fromList $ zipWith (curry mkAssoc) [0..] a where 
>     mkAssoc (i,c) = (freq, c) where
>         samplesPerPeriod = fromIntegral (length a)
>         freq = i * (clockRate / samplesPerPeriod)

Given a quantization frequency (the number of samples between each 
successive FFT calculation) and a fundamental period, this will decompose
the input signal into its constituent frequencies.
NOTE: The fundamental period must be a power of two!

> fftA :: ArrowCircuit a => Int -> Int -> a Double (SEvent [Double])
> fftA qf fp = proc d -> do
>     carray <- quantize fp qf -< d :+ 0
>     returnA -< fmap (map magnitude . take (fp `div` 2) . fft) carray