-----------------------------------------------------------------------------
-- |
-- Module      :  DSP.Filter.FIR.FIR
-- Copyright   :  (c) Matthew Donadio 2003
-- License     :  GPL
--
-- Maintainer  :  m.p.donadio@ieee.org
-- Stability   :  experimental
-- Portability :  portable
--
-- Finite Impuse Response filtering functions
--
-----------------------------------------------------------------------------

module DSP.Filter.FIR.FIR (fir, test) where

import Data.Array

-- | Implements the following function, which is a FIR filter
--
-- @y[n] = sum(k=0,M) h[k]*x[n-k]@
--
-- We implement the fir function with five helper functions, depending on
-- the type of the filter.  In the following functions, we use the O&S
-- convention that m is the order of the filter, which is equal to the
-- number of taps minus one.

{-# specialize fir :: Array Int Float ->  [Float]  -> [Float]  #-}
{-# specialize fir :: Array Int Double -> [Double] -> [Double] #-}

fir :: (Num a, Eq a) => Array Int a -- ^ h[n]
    -> [a] -- ^ x[n]
    -> [a] -- ^ y[n]

fir :: forall a. (Num a, Eq a) => Array Int a -> [a] -> [a]
fir Array Int a
_ [] = []
fir Array Int a
h (a
x:[a]
xs) | forall a. (Num a, Eq a) => Array Int a -> Bool
isFIRType1 Array Int a
h = forall a. Num a => Array Int a -> Array Int a -> [a] -> [a]
fir'1 Array Int a
h Array Int a
w [a]
xs
             | forall a. (Num a, Eq a) => Array Int a -> Bool
isFIRType2 Array Int a
h = forall a. Num a => Array Int a -> Array Int a -> [a] -> [a]
fir'2 Array Int a
h Array Int a
w [a]
xs
             | forall a. (Num a, Eq a) => Array Int a -> Bool
isFIRType3 Array Int a
h = forall a. Num a => Array Int a -> Array Int a -> [a] -> [a]
fir'3 Array Int a
h Array Int a
w [a]
xs
             | forall a. (Num a, Eq a) => Array Int a -> Bool
isFIRType4 Array Int a
h = forall a. Num a => Array Int a -> Array Int a -> [a] -> [a]
fir'4 Array Int a
h Array Int a
w [a]
xs
             | Bool
otherwise    = forall a. Num a => Array Int a -> Array Int a -> [a] -> [a]
fir'0 Array Int a
h Array Int a
w [a]
xs
    where w :: Array Int a
w = forall i e. Ix i => (i, i) -> [e] -> Array i e
listArray (Int
0,Int
m) forall a b. (a -> b) -> a -> b
$ a
x forall a. a -> [a] -> [a]
: forall a. Int -> a -> [a]
replicate Int
m a
0
	  m :: Int
m = forall a b. (a, b) -> b
snd forall a b. (a -> b) -> a -> b
$ forall i e. Array i e -> (i, i)
bounds Array Int a
h

-- This is for testing the symmetric helpers.

fir0 :: Num a => Array Int a -> [a] -> [a]
fir0 :: forall a. Num a => Array Int a -> [a] -> [a]
fir0 Array Int a
_ []     = []
fir0 Array Int a
h (a
x:[a]
xs) = forall a. Num a => Array Int a -> Array Int a -> [a] -> [a]
fir'0 Array Int a
h Array Int a
w [a]
xs
    where w :: Array Int a
w = forall i e. Ix i => (i, i) -> [e] -> Array i e
listArray (Int
0,Int
m) forall a b. (a -> b) -> a -> b
$ a
x forall a. a -> [a] -> [a]
: forall a. Int -> a -> [a]
replicate Int
m a
0
	  m :: Int
m = forall a b. (a, b) -> b
snd forall a b. (a -> b) -> a -> b
$ forall i e. Array i e -> (i, i)
bounds Array Int a
h

-- Asymmetric FIR

{-# specialize fir'0 :: Array Int Float ->  Array Int Float ->  [Float]  -> [Float]  #-}
{-# specialize fir'0 :: Array Int Double -> Array Int Double -> [Double] -> [Double] #-}

fir'0 :: Num a => Array Int a -> Array Int a -> [a] -> [a]
fir'0 :: forall a. Num a => Array Int a -> Array Int a -> [a] -> [a]
fir'0 Array Int a
h Array Int a
w []     = a
y forall a. a -> [a] -> [a]
: []
    where y :: a
y  = forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
sum [ Array Int a
hforall i e. Ix i => Array i e -> i -> e
!Int
i forall a. Num a => a -> a -> a
* Array Int a
wforall i e. Ix i => Array i e -> i -> e
!Int
i | Int
i <- [Int
0..Int
m] ]
	  m :: Int
m  = forall a b. (a, b) -> b
snd forall a b. (a -> b) -> a -> b
$ forall i e. Array i e -> (i, i)
bounds Array Int a
h
fir'0 Array Int a
h Array Int a
w (a
x:[a]
xs) = a
y forall a. a -> [a] -> [a]
: forall a. Num a => Array Int a -> Array Int a -> [a] -> [a]
fir'0 Array Int a
h Array Int a
w' [a]
xs
    where y :: a
y  = forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
sum [ Array Int a
hforall i e. Ix i => Array i e -> i -> e
!Int
i forall a. Num a => a -> a -> a
* Array Int a
wforall i e. Ix i => Array i e -> i -> e
!Int
i | Int
i <- [Int
0..Int
m] ]
          w' :: Array Int a
w' = forall i e. Ix i => (i, i) -> [e] -> Array i e
listArray (Int
0,Int
m) forall a b. (a -> b) -> a -> b
$ a
x forall a. a -> [a] -> [a]
: forall i e. Array i e -> [e]
elems Array Int a
w
	  m :: Int
m  = forall a b. (a, b) -> b
snd forall a b. (a -> b) -> a -> b
$ forall i e. Array i e -> (i, i)
bounds Array Int a
h

-- Type 1: symmetric FIR, even order / odd length

{-# specialize fir'1 :: Array Int Float ->  Array Int Float ->  [Float]  -> [Float]  #-}
{-# specialize fir'1 :: Array Int Double -> Array Int Double -> [Double] -> [Double] #-}

fir'1 :: Num a => Array Int a -> Array Int a -> [a] -> [a]
fir'1 :: forall a. Num a => Array Int a -> Array Int a -> [a] -> [a]
fir'1 Array Int a
h Array Int a
w []     = a
y forall a. a -> [a] -> [a]
: []
    where y :: a
y  = Array Int a
hforall i e. Ix i => Array i e -> i -> e
!Int
m2 forall a. Num a => a -> a -> a
* Array Int a
wforall i e. Ix i => Array i e -> i -> e
!Int
m2 forall a. Num a => a -> a -> a
+ forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
sum [ Array Int a
hforall i e. Ix i => Array i e -> i -> e
!Int
i forall a. Num a => a -> a -> a
* (Array Int a
wforall i e. Ix i => Array i e -> i -> e
!Int
i forall a. Num a => a -> a -> a
+ Array Int a
wforall i e. Ix i => Array i e -> i -> e
!(Int
mforall a. Num a => a -> a -> a
-Int
i)) | Int
i <- [Int
0..Int
m2forall a. Num a => a -> a -> a
-Int
1] ]
	  m :: Int
m  = forall a b. (a, b) -> b
snd forall a b. (a -> b) -> a -> b
$ forall i e. Array i e -> (i, i)
bounds Array Int a
h
	  m2 :: Int
m2 = Int
m forall a. Integral a => a -> a -> a
`div` Int
2
fir'1 Array Int a
h Array Int a
w (a
x:[a]
xs) = a
y forall a. a -> [a] -> [a]
: forall a. Num a => Array Int a -> Array Int a -> [a] -> [a]
fir'1 Array Int a
h Array Int a
w' [a]
xs
    where y :: a
y  = Array Int a
hforall i e. Ix i => Array i e -> i -> e
!Int
m2 forall a. Num a => a -> a -> a
* Array Int a
wforall i e. Ix i => Array i e -> i -> e
!Int
m2 forall a. Num a => a -> a -> a
+ forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
sum [ Array Int a
hforall i e. Ix i => Array i e -> i -> e
!Int
i forall a. Num a => a -> a -> a
* (Array Int a
wforall i e. Ix i => Array i e -> i -> e
!Int
i forall a. Num a => a -> a -> a
+ Array Int a
wforall i e. Ix i => Array i e -> i -> e
!(Int
mforall a. Num a => a -> a -> a
-Int
i)) | Int
i <- [Int
0..Int
m2forall a. Num a => a -> a -> a
-Int
1] ]
          w' :: Array Int a
w' = forall i e. Ix i => (i, i) -> [e] -> Array i e
listArray (Int
0,Int
m) forall a b. (a -> b) -> a -> b
$ a
x forall a. a -> [a] -> [a]
: forall i e. Array i e -> [e]
elems Array Int a
w
	  m :: Int
m  = forall a b. (a, b) -> b
snd forall a b. (a -> b) -> a -> b
$ forall i e. Array i e -> (i, i)
bounds Array Int a
h
	  m2 :: Int
m2 = Int
m forall a. Integral a => a -> a -> a
`div` Int
2

-- Type 2: symmetric FIR, odd order / even length

{-# specialize fir'2 :: Array Int Float ->  Array Int Float ->  [Float]  -> [Float]  #-}
{-# specialize fir'2 :: Array Int Double -> Array Int Double -> [Double] -> [Double] #-}

fir'2 :: Num a => Array Int a -> Array Int a -> [a] -> [a]
fir'2 :: forall a. Num a => Array Int a -> Array Int a -> [a] -> [a]
fir'2 Array Int a
h Array Int a
w []     = a
y forall a. a -> [a] -> [a]
: []
    where y :: a
y  = forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
sum [ Array Int a
hforall i e. Ix i => Array i e -> i -> e
!Int
i forall a. Num a => a -> a -> a
* (Array Int a
wforall i e. Ix i => Array i e -> i -> e
!Int
i forall a. Num a => a -> a -> a
+ Array Int a
wforall i e. Ix i => Array i e -> i -> e
!(Int
mforall a. Num a => a -> a -> a
-Int
i)) | Int
i <- [Int
0..Int
m2] ]
	  m :: Int
m  = forall a b. (a, b) -> b
snd forall a b. (a -> b) -> a -> b
$ forall i e. Array i e -> (i, i)
bounds Array Int a
h
	  m2 :: Int
m2 = Int
m forall a. Integral a => a -> a -> a
`div` Int
2
fir'2 Array Int a
h Array Int a
w (a
x:[a]
xs) = a
y forall a. a -> [a] -> [a]
: forall a. Num a => Array Int a -> Array Int a -> [a] -> [a]
fir'2 Array Int a
h Array Int a
w' [a]
xs
    where y :: a
y  = forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
sum [ Array Int a
hforall i e. Ix i => Array i e -> i -> e
!Int
i forall a. Num a => a -> a -> a
* (Array Int a
wforall i e. Ix i => Array i e -> i -> e
!Int
i forall a. Num a => a -> a -> a
+ Array Int a
wforall i e. Ix i => Array i e -> i -> e
!(Int
mforall a. Num a => a -> a -> a
-Int
i)) | Int
i <- [Int
0..Int
m2] ]
          w' :: Array Int a
w' = forall i e. Ix i => (i, i) -> [e] -> Array i e
listArray (Int
0,Int
m) forall a b. (a -> b) -> a -> b
$ a
x forall a. a -> [a] -> [a]
: forall i e. Array i e -> [e]
elems Array Int a
w
	  m :: Int
m  = forall a b. (a, b) -> b
snd forall a b. (a -> b) -> a -> b
$ forall i e. Array i e -> (i, i)
bounds Array Int a
h
	  m2 :: Int
m2 = Int
m forall a. Integral a => a -> a -> a
`div` Int
2

-- Type 3: anti-symmetric FIR, even order / odd length

{-# specialize fir'3 :: Array Int Float ->  Array Int Float ->  [Float]  -> [Float]  #-}
{-# specialize fir'3 :: Array Int Double -> Array Int Double -> [Double] -> [Double] #-}

fir'3 :: Num a => Array Int a -> Array Int a -> [a] -> [a]
fir'3 :: forall a. Num a => Array Int a -> Array Int a -> [a] -> [a]
fir'3 Array Int a
h Array Int a
w []     = a
y forall a. a -> [a] -> [a]
: []
    where y :: a
y  = Array Int a
hforall i e. Ix i => Array i e -> i -> e
!Int
m2 forall a. Num a => a -> a -> a
* Array Int a
wforall i e. Ix i => Array i e -> i -> e
!Int
m2 forall a. Num a => a -> a -> a
+ forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
sum [ Array Int a
hforall i e. Ix i => Array i e -> i -> e
!Int
i forall a. Num a => a -> a -> a
* (Array Int a
wforall i e. Ix i => Array i e -> i -> e
!Int
i forall a. Num a => a -> a -> a
- Array Int a
wforall i e. Ix i => Array i e -> i -> e
!(Int
mforall a. Num a => a -> a -> a
-Int
i)) | Int
i <- [Int
0..Int
m2forall a. Num a => a -> a -> a
-Int
1] ]
	  m :: Int
m  = forall a b. (a, b) -> b
snd forall a b. (a -> b) -> a -> b
$ forall i e. Array i e -> (i, i)
bounds Array Int a
h
	  m2 :: Int
m2 = Int
m forall a. Integral a => a -> a -> a
`div` Int
2
fir'3 Array Int a
h Array Int a
w (a
x:[a]
xs) = a
y forall a. a -> [a] -> [a]
: forall a. Num a => Array Int a -> Array Int a -> [a] -> [a]
fir'3 Array Int a
h Array Int a
w' [a]
xs
    where y :: a
y  = Array Int a
hforall i e. Ix i => Array i e -> i -> e
!Int
m2 forall a. Num a => a -> a -> a
* Array Int a
wforall i e. Ix i => Array i e -> i -> e
!Int
m2 forall a. Num a => a -> a -> a
+ forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
sum [ Array Int a
hforall i e. Ix i => Array i e -> i -> e
!Int
i forall a. Num a => a -> a -> a
* (Array Int a
wforall i e. Ix i => Array i e -> i -> e
!Int
i forall a. Num a => a -> a -> a
- Array Int a
wforall i e. Ix i => Array i e -> i -> e
!(Int
mforall a. Num a => a -> a -> a
-Int
i)) | Int
i <- [Int
0..Int
m2forall a. Num a => a -> a -> a
-Int
1] ]
          w' :: Array Int a
w' = forall i e. Ix i => (i, i) -> [e] -> Array i e
listArray (Int
0,Int
m) forall a b. (a -> b) -> a -> b
$ a
x forall a. a -> [a] -> [a]
: forall i e. Array i e -> [e]
elems Array Int a
w
	  m :: Int
m  = forall a b. (a, b) -> b
snd forall a b. (a -> b) -> a -> b
$ forall i e. Array i e -> (i, i)
bounds Array Int a
h
	  m2 :: Int
m2 = Int
m forall a. Integral a => a -> a -> a
`div` Int
2

-- Type 4: anti-symmetric FIR, off order / even length

{-# specialize fir'4 :: Array Int Float ->  Array Int Float ->  [Float]  -> [Float]  #-}
{-# specialize fir'4 :: Array Int Double -> Array Int Double -> [Double] -> [Double] #-}

fir'4 :: Num a => Array Int a -> Array Int a -> [a] -> [a]
fir'4 :: forall a. Num a => Array Int a -> Array Int a -> [a] -> [a]
fir'4 Array Int a
h Array Int a
w []     = a
y forall a. a -> [a] -> [a]
: []
    where y :: a
y  = forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
sum [ Array Int a
hforall i e. Ix i => Array i e -> i -> e
!Int
i forall a. Num a => a -> a -> a
* (Array Int a
wforall i e. Ix i => Array i e -> i -> e
!Int
i forall a. Num a => a -> a -> a
- Array Int a
wforall i e. Ix i => Array i e -> i -> e
!(Int
mforall a. Num a => a -> a -> a
-Int
i)) | Int
i <- [Int
0..Int
m2] ]
	  m :: Int
m  = forall a b. (a, b) -> b
snd forall a b. (a -> b) -> a -> b
$ forall i e. Array i e -> (i, i)
bounds Array Int a
h
	  m2 :: Int
m2 = Int
m forall a. Integral a => a -> a -> a
`div` Int
2
fir'4 Array Int a
h Array Int a
w (a
x:[a]
xs) = a
y forall a. a -> [a] -> [a]
: forall a. Num a => Array Int a -> Array Int a -> [a] -> [a]
fir'4 Array Int a
h Array Int a
w' [a]
xs
    where y :: a
y  = forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
sum [ Array Int a
hforall i e. Ix i => Array i e -> i -> e
!Int
i forall a. Num a => a -> a -> a
* (Array Int a
wforall i e. Ix i => Array i e -> i -> e
!Int
i forall a. Num a => a -> a -> a
- Array Int a
wforall i e. Ix i => Array i e -> i -> e
!(Int
mforall a. Num a => a -> a -> a
-Int
i)) | Int
i <- [Int
0..Int
m2] ]
          w' :: Array Int a
w' = forall i e. Ix i => (i, i) -> [e] -> Array i e
listArray (Int
0,Int
m) forall a b. (a -> b) -> a -> b
$ a
x forall a. a -> [a] -> [a]
: forall i e. Array i e -> [e]
elems Array Int a
w
	  m :: Int
m  = forall a b. (a, b) -> b
snd forall a b. (a -> b) -> a -> b
$ forall i e. Array i e -> (i, i)
bounds Array Int a
h
	  m2 :: Int
m2 = Int
m forall a. Integral a => a -> a -> a
`div` Int
2

-- Aux functions.  Note that the tap numbers go from [0..m], so if m is
-- even, then the filter has odd length, and vice versa.

{-# specialize isFIRType1 :: Array Int Float ->  Bool  #-}
{-# specialize isFIRType1 :: Array Int Double -> Bool #-}

isFIRType1 :: (Num a, Eq a) => Array Int a -> Bool
isFIRType1 :: forall a. (Num a, Eq a) => Array Int a -> Bool
isFIRType1 Array Int a
h = forall a. Integral a => a -> Bool
even Int
m Bool -> Bool -> Bool
&& ([a]
h' forall a. Eq a => a -> a -> Bool
== (forall a. [a] -> [a]
reverse [a]
h'))
    where m :: Int
m = forall a b. (a, b) -> b
snd forall a b. (a -> b) -> a -> b
$ forall i e. Array i e -> (i, i)
bounds Array Int a
h
	  h' :: [a]
h' = forall i e. Array i e -> [e]
elems Array Int a
h

{-# specialize isFIRType2 :: Array Int Float ->  Bool  #-}
{-# specialize isFIRType2 :: Array Int Double -> Bool #-}

isFIRType2 :: (Num a, Eq a) => Array Int a -> Bool
isFIRType2 :: forall a. (Num a, Eq a) => Array Int a -> Bool
isFIRType2 Array Int a
h = forall a. Integral a => a -> Bool
odd Int
m Bool -> Bool -> Bool
&& ([a]
h' forall a. Eq a => a -> a -> Bool
== (forall a. [a] -> [a]
reverse [a]
h'))
    where m :: Int
m = forall a b. (a, b) -> b
snd forall a b. (a -> b) -> a -> b
$ forall i e. Array i e -> (i, i)
bounds Array Int a
h
	  h' :: [a]
h' = forall i e. Array i e -> [e]
elems Array Int a
h

{-# specialize isFIRType3 :: Array Int Float ->  Bool  #-}
{-# specialize isFIRType3 :: Array Int Double -> Bool #-}

isFIRType3 :: (Num a, Eq a) => Array Int a -> Bool
isFIRType3 :: forall a. (Num a, Eq a) => Array Int a -> Bool
isFIRType3 Array Int a
h = forall a. Integral a => a -> Bool
even Int
m Bool -> Bool -> Bool
&& [a]
ha forall a. Eq a => a -> a -> Bool
== forall a. [a] -> [a]
reverse [a]
hb
    where m :: Int
m = forall a b. (a, b) -> b
snd forall a b. (a -> b) -> a -> b
$ forall i e. Array i e -> (i, i)
bounds Array Int a
h
	  h' :: [a]
h' = forall i e. Array i e -> [e]
elems Array Int a
h
	  ha :: [a]
ha = forall a. Int -> [a] -> [a]
take Int
n [a]
h'
          hb :: [a]
hb = forall a b. (a -> b) -> [a] -> [b]
map forall a. Num a => a -> a
negate (forall a. Int -> [a] -> [a]
drop (Int
nforall a. Num a => a -> a -> a
+Int
1) [a]
h')
          n :: Int
n = Int
m forall a. Integral a => a -> a -> a
`div` Int
2

{-# specialize isFIRType4 :: Array Int Float ->  Bool #-}
{-# specialize isFIRType4 :: Array Int Double -> Bool #-}

isFIRType4 :: (Num a, Eq a) => Array Int a -> Bool
isFIRType4 :: forall a. (Num a, Eq a) => Array Int a -> Bool
isFIRType4 Array Int a
h = forall a. Integral a => a -> Bool
odd Int
m Bool -> Bool -> Bool
&& [a]
ha forall a. Eq a => a -> a -> Bool
== forall a. [a] -> [a]
reverse [a]
hb
    where m :: Int
m = forall a b. (a, b) -> b
snd forall a b. (a -> b) -> a -> b
$ forall i e. Array i e -> (i, i)
bounds Array Int a
h
	  ha :: [a]
ha = forall i e. Array i e -> [e]
elems Array Int a
h
	  hb :: [a]
hb = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a. Num a => a -> a
negate forall a b. (a -> b) -> a -> b
$ [a]
ha

-- Test routines

-- This tests out fir'0

ht :: Array Int Double
ht :: Array Int Double
ht = forall i e. Ix i => (i, i) -> [e] -> Array i e
listArray (Int
0,Int
4) [ Double
1, Double
2, Double
0, -Double
1, Double
1 ]

xt :: [Double]
xt :: [Double]
xt = [Double
1, Double
3, -Double
1, -Double
2, Double
0, Double
0, Double
0, Double
0 ]

yt :: [Double]
yt :: [Double]
yt = [Double
1, Double
5, Double
5, -Double
5, -Double
6, Double
4, Double
1, -Double
2]

yt' :: [Double]
yt' :: [Double]
yt' = forall a. (Num a, Eq a) => Array Int a -> [a] -> [a]
fir Array Int Double
ht [Double]
xt

-- This checks the symmetric routines against fir'0

h1 :: Array Int Double
h1 :: Array Int Double
h1 = forall i e. Ix i => (i, i) -> [e] -> Array i e
listArray (Int
0,Int
4) [ Double
1, Double
2, Double
3, Double
2, Double
1 ]
h2 :: Array Int Double
h2 :: Array Int Double
h2 = forall i e. Ix i => (i, i) -> [e] -> Array i e
listArray (Int
0,Int
5) [ Double
1, Double
2, Double
3, Double
3, Double
2, Double
1 ]
h3 :: Array Int Double
h3 :: Array Int Double
h3 = forall i e. Ix i => (i, i) -> [e] -> Array i e
listArray (Int
0,Int
4) [ Double
1, Double
2, Double
3, -Double
2, -Double
1 ]
h4 :: Array Int Double
h4 :: Array Int Double
h4 = forall i e. Ix i => (i, i) -> [e] -> Array i e
listArray (Int
0,Int
5) [ Double
1, Double
2, Double
3, -Double
3, -Double
2, -Double
1 ]

y1, y2, y3, y4 :: [Double]
y1 :: [Double]
y1 = forall a. Num a => Array Int a -> [a] -> [a]
fir0 Array Int Double
h1 [Double]
xt
y2 :: [Double]
y2 = forall a. Num a => Array Int a -> [a] -> [a]
fir0 Array Int Double
h2 [Double]
xt
y3 :: [Double]
y3 = forall a. Num a => Array Int a -> [a] -> [a]
fir0 Array Int Double
h3 [Double]
xt
y4 :: [Double]
y4 = forall a. Num a => Array Int a -> [a] -> [a]
fir0 Array Int Double
h4 [Double]
xt

y1', y2', y3', y4' :: [Double]
y1' :: [Double]
y1' = forall a. (Num a, Eq a) => Array Int a -> [a] -> [a]
fir Array Int Double
h1 [Double]
xt
y2' :: [Double]
y2' = forall a. (Num a, Eq a) => Array Int a -> [a] -> [a]
fir Array Int Double
h2 [Double]
xt
y3' :: [Double]
y3' = forall a. (Num a, Eq a) => Array Int a -> [a] -> [a]
fir Array Int Double
h3 [Double]
xt
y4' :: [Double]
y4' = forall a. (Num a, Eq a) => Array Int a -> [a] -> [a]
fir Array Int Double
h4 [Double]
xt

-- If everything works, then test == True

test :: Bool
test :: Bool
test = forall (t :: * -> *). Foldable t => t Bool -> Bool
and [ [Double]
yt forall a. Eq a => a -> a -> Bool
== [Double]
yt', [Double]
y1 forall a. Eq a => a -> a -> Bool
== [Double]
y1', [Double]
y2 forall a. Eq a => a -> a -> Bool
== [Double]
y2', [Double]
y3 forall a. Eq a => a -> a -> Bool
== [Double]
y3', [Double]
y4 forall a. Eq a => a -> a -> Bool
== [Double]
y4' ]