Move all into Signal Module, fix for ghc7.10 (at least)

.gitignore

@@ -14,4 +14,4 @@ Test/MiniTest.hs
 Test/buganalysis.hs
 Test/log.txt
 Test/debug.nb
-Test/debugs.dat
+Test/debugs.dat

Signal.cabal

@@ -14,47 +14,55 @@ maintainer:          misc@alpheccar.org
 copyright:           2013, alpheccar.org          
 category:            Math
 build-type:          Simple
-cabal-version:       >=1.8
+cabal-version:       >=1.10
 
 library
+  default-language: Haskell2010
+  other-extensions:
+       CPP
+
+  hs-source-dirs: src
   exposed-modules: 
-    Transform
-    Plot    
-    Signal 
-    Generators
-    Fixed
-    TestCases
-    Common
-    Windows
-    SpecialInt
-    Trace
-    AudioFile
-    MultiRate
-    Spectrogram
-    VAD
-    Noise
-    Filter
+    Signal.Transform
+    Signal.Plot
+    Signal
+    Signal.Generators
+    Signal.Fixed
+    Signal.TestCases
+    Signal.Common
+    Signal.Windows
+    Signal.SpecialInt
+    Signal.Trace
+    Signal.AudioFile
+    Signal.MultiRate
+    Signal.Spectrogram
+    Signal.VAD
+    Signal.Noise
+    Signal.Filter
   other-modules:
-    TypeAddition
-    Internal 
+    Signal.Internal
   build-depends:       
-     base ==4.6.*,
-     vector ==0.10.*,
-     hmatrix ==0.14.*,
-     stream-fusion ==0.1.*,
-     HPDF ==1.4.*,
-     HaskellViewer >=0.4.2.1,
-     test-framework ==0.8.*,
-     test-framework-hunit ==0.3.*,
-     HUnit ==1.2.5.*,
-     primitive ==0.5.*,
-     containers ==0.5.*,
-     statistics ==0.10.*,
-     deepseq ==1.3.*,
-     random ==1.0.*,
-     WAVE ==0.1.*,
-     mtl ==2.1.*,
-     polynomial ==0.6.*
-  ghc-options: -O2
+     base,
+     vector,
+     hmatrix,
+     hmatrix-gsl,
+     stream-fusion,
+     HPDF,
+     HaskellViewer,
+     test-framework,
+     test-framework-hunit,
+     HUnit,
+     primitive,
+     containers,
+     statistics,
+     deepseq,
+     random,
+     WAVE,
+     mtl,
+     polynomial,
+     singletons
+
   if (os(darwin))
-    ghc-options: -pgmP llvm-gcc-4.2 -optP-E
+    ghc-options: -pgmP llvm-gcc-4.2 -optP-E
+  else
+    ghc-options: -O2 -cpp  -pgmPcpphs  -optP--cpp

Test/Test.hs

@@ -3,37 +3,37 @@
 {-# LANGUAGE BangPatterns #-}
 {-# LANGUAGE GADTs #-}
 module Main(
-	  main
-	
-	) where 
+          main
+
+        ) where
 
 import Prelude hiding((++))
-import Plot
+import Signal.Plot
 import Graphics.PDF hiding(Orientation(..), Vertical)
-import Transform
+import Signal.Transform
 import Signal
-import Generators
-import Fixed
-import TestCases
-import Common 
-import Windows
+import Signal.Generators
+import Signal.Fixed
+import Signal.TestCases
+import Signal.Common
+import Signal.Windows
 import qualified Data.Vector.Unboxed as U
 import qualified Numeric.GSL.Fourier as F
-import Trace
+import Signal.Trace
 import System.Random 
-import Displayable
+import HaskellViewer.Displayable
 import Control.DeepSeq
 import Control.Applicative((<$>))
-import AudioFile 
-import Playable 
-import Viewer(play)
-import Spectrogram 
-import VAD
+import Signal.AudioFile
+import HaskellViewer.Playable
+import HaskellViewer.Viewer(play)
+import Signal.Spectrogram
+import Signal.VAD
 import Data.List.Stream((++))
 import System.Timeout
-import Noise
+import Signal.Noise
 import System.IO
-import Filter
+import Signal.Filter
 import Math.Polynomial 
 
 import qualified Debug.Trace as T
@@ -133,17 +133,27 @@ wav = do
   let theTimes = uniformSamples (period s) 0.0
   display $ plotSignals (floor $ 2.0 * getF (rate s))  (period s) [ AS s]
 
+avad = do
+  s <- readMono "Test.wav" :: IO (Sampled Time Double)
+  let v = vad s
+  let theTimes = uniformSamples (period s) 0.0
+  display $ plotSignals (floor $ 2.0 * getF (rate s))  (period s) [ AS s, AS v]
+
+
 myTest = do
-  --s <- readMono "Test.wav" :: IO (Signal Time Double)
+  s <- readMono "Test.wav" :: IO (Sampled Time Double)
   let tr = dual (Frequency 44100)
+--       theTimes = {-# SCC "theTimes" #-} uniformSamples s 0.0 :: Signal Time
       theTimes = {-# SCC "theTimes" #-} uniformSamples tr 0.0 :: Signal Time
       --s = mapS (\t -> 0.01*sin (2*pi*4000*getT t)) theTimes
-      --si = vad s
-      sv = tr
-      ----theFrames = uniformSamples sv 0
+      si = vad s
+--       sv = tr
+      sv = si
+--       theFrames = uniformSamples sv 0
       --myLen !s (!a:l) = myLen (s+1) l
       --myLen !s [] = s
-  display $ discreteSignalsWithStyle (floor $ 6.0 / getT sv)  plotStyle { horizontalBounds = Just (0,6.0)
+--   display $ discreteSignalsWithStyle (floor $ 6.0 / getT sv)  plotStyle { horizontalBounds = Just (0,6.0)
+  display $ discreteSignalsWithStyle (floor $ 6.0 /  samplingPeriod s)  plotStyle { horizontalBounds = Just (0,6.0)
                                                                         , verticalBounds = Just (0,6.0)
                                                                         }
                 [ AS theTimes]
@@ -254,22 +264,22 @@ lightGreen = Rgb 0.6 1.0 0.6
 lightYellow = Rgb 1.0 1.0 0.6
 
 plotStyle =  
-	(defaultPlotStyle { title = Just "Temporal"
-        	          , signalStyles = [ defaultSignalStyle 0.8 lightBlue
-        	                           , defaultSignalStyle 0.8 lightRed
-        	                           , defaultSignalStyle 0.8 lightGreen
+        (defaultPlotStyle { title = Just "Temporal"
+                          , signalStyles = [ defaultSignalStyle 0.8 lightBlue
+                                           , defaultSignalStyle 0.8 lightRed
+                                           , defaultSignalStyle 0.8 lightGreen
                                      , defaultSignalStyle 0.8 lightYellow
-        	                           ]
-        	          , verticalLabel = Just "Amplitude"
-        	          })  
+                                           ]
+                          , verticalLabel = Just "Amplitude"
+                          })
 fftStyle = 
-	plotStyle { verticalLabel = Just "Energy", title = Just "Frequential", horizontalLabel = Just "Hz"
+        plotStyle { verticalLabel = Just "Energy", title = Just "Frequential", horizontalLabel = Just "Hz"
                      , signalStyles = [ defaultSignalStyle 0.8 lightBlue
-        	                            , defaultSignalStyle 0.8 lightRed
-        	                            , defaultSignalStyle 0.8 lightGreen
+                                            , defaultSignalStyle 0.8 lightRed
+                                            , defaultSignalStyle 0.8 lightGreen
                                       , defaultSignalStyle 0.8 lightYellow
-        	                          ]
-        	         }
+                                          ]
+                         }
 
 pict = display $ plotSignals (floor $ getT dr * getF samplingFrequency) sp [ AS mySignalA
                                                                            , AS mySignalC

Signal.hs → src/Signal.hs

@@ -3,15 +3,15 @@
 {-# LANGUAGE FlexibleInstances #-}
 {-# LANGUAGE UndecidableInstances #-}
 module Signal(
-	Signal,
+        Signal,
     BSignal, 
     getSamples,
     duration,
     nbSamples,
     Sample(..),
     DualVal(..),
     samplingRate,
-	   -- * Basic interface
+           -- * Basic interface
     headS,                   
     tailS, 
     consS,  
@@ -105,20 +105,24 @@ module Signal(
     Sampled(..),
     HasPeriod(..),
     HasSamples(..)
-	) where 
+        ) where
 
 import qualified Prelude as P
 import Prelude(Int(..),Maybe(..),Bool(..),Eq(..),Integral(..),($),(.),Num(..),Ord(..),Show
               ,otherwise,Floating,Fractional,Real,Read,RealFloat,RealFrac)
-import Internal
+
 import qualified Data.Vector.Unboxed as U
 import Data.Vector.Unboxed((!),Unbox(..))
+
 import Data.Stream(stream,unstream,Stream(..),Step(..),L(..))
 import Data.List.Stream
-import Common(HasDoubleRepresentation(..))
-import Playable
-import Common 
-import Viewer(play)
+
+import HaskellViewer.Playable
+import HaskellViewer.Viewer(play)
+
+import Signal.Common
+import Signal.Common(HasDoubleRepresentation(..))
+import Signal.Internal
 
 type Sample a = (RealFrac a, RealFloat a, HasDoubleRepresentation a, Unbox a)
 
@@ -318,9 +322,9 @@ genericReplicateS n x = Signal (genericReplicate n x)
 fromVectorS :: Unbox a => a -> U.Vector a -> Signal a
 fromVectorS d v = Signal $ unstream (repeatVector d)
  where 
- 	repeatVector d = Stream (nextS d) (L 0)
- 	nextS d l@(L !i) | i < U.length v = Yield (v!i) (L (i+1))
- 	                 | otherwise = Yield d l
+        repeatVector d = Stream (nextS d) (L 0)
+        nextS d l@(L !i) | i < U.length v = Yield (v!i) (L (i+1))
+                         | otherwise = Yield d l
 {-# INLINE [0] fromVectorS #-}
 
 fromVectorBS :: Unbox a => U.Vector a -> BSignal a