synthesizer-core-0.9: speedtest/Fourier.hs

module Main where

import qualified Synthesizer.Storable.Signal as SigSt
import qualified Synthesizer.Generic.Fourier as Fourier
import qualified Synthesizer.Generic.Noise as NoiseG
import qualified Synthesizer.Generic.Signal as SigG
import qualified Synthesizer.State.Noise as NoiseS
import qualified Synthesizer.State.Signal as SigS

import qualified Data.StorableVector.Lazy.Typed as SVT
import qualified Data.StorableVector as SV

import qualified Number.Complex as NPComplex

import System.TimeIt (timeIt, )

import NumericPrelude.Numeric
import NumericPrelude.Base
import Prelude ()



test0 :: IO ()
test0 =
   SigSt.writeFile "fouriertest.f64" $
   SigG.take 65536 $
   SVT.toVectorLazy $
   (NoiseG.white :: SVT.DefaultVector Double)

test1 :: IO ()
test1 =
   SigSt.writeFile "fouriertest.f64" $
   SigS.toStorableSignal SigSt.defaultChunkSize $
   SigS.take 65536 $
   SigS.map (NPComplex.+: 0) $
   (NoiseS.white :: SigS.T Double)

test2 :: Int -> IO ()
test2 n =
   writeFile "fouriertest.cache" $
   show $ Fourier.cacheBackward $
   (\sig ->
      SigS.toStorableSignal SigSt.defaultChunkSize sig ::
         SigSt.T (NPComplex.T Double)) $
   SigS.take n $
   SigS.map (NPComplex.+: 0) $
   NoiseS.white

test3 :: Int -> IO ()
test3 n =
   let sig :: SigSt.T (NPComplex.T Double)
       sig =
          SigS.toStorableSignal SigSt.defaultChunkSize $
          SigS.take n $
          SigS.map (NPComplex.+: 0) $
          NoiseS.white
       cache =
          Fourier.cacheBackward sig
   in  do timeIt $ writeFile "fouriertest.cache" $ show cache
          timeIt $ SigSt.writeFile "fouriertest.f64" $
             Fourier.transformWithCache cache sig

test4 :: Int -> IO ()
test4 n =
   let sig :: SV.Vector (NPComplex.T Double)
       sig =
          SigS.toStrictStorableSignal n $
          SigS.take n $
          SigS.map (NPComplex.+: 0) $
          NoiseS.white
       cache =
          Fourier.cacheBackward sig
   in  do -- timeIt $ writeFile "fouriertest.cache" $ show cache
          timeIt $ SV.writeFile "fouriertest.f64" $
             Fourier.transformWithCache cache sig


main :: IO ()
main =
--   timeIt $ test2 (4096*3+1)
--   test4 (4096*3+1)
   sequence_ $
   timeIt test0 : timeIt test1 :
   map test4
      (16384 : (4096*3) : (4096*3+1) : 11025 :
       (3^9) : (5^6) : (7^5) :
       (6^6) : (3*5*7*11*13) :
       [])
{-
      (65536 : 65537 : 44100 :
       (3^10) : (5^7) : (7^5) :
       (6^6) : (2*3*5*7*11*13) :
       [])
-}