-----------------------------------------------------------------------------
-- |
-- Module      :  DSP.Unwrap
-- Copyright   :  (c) Matthew Donadio 2003
-- License     :  GPL
--
-- Maintainer  :  m.p.donadio@ieee.org
-- Stability   :  experimental
-- Portability :  portable
--
-- Simple phase unwrapping algorithm
--
-----------------------------------------------------------------------------

-- O&S, pg 790

module DSP.Unwrap (unwrap) where

import Data.Array

-- * Functions

-- | This is the simple phase unwrapping algorithm from Oppenheim and
-- Schafer.

unwrap :: (Ix a, Integral a, Ord b, Floating b) => b         -- ^ epsilon
                                                -> Array a b -- ^ ARG
						-> Array a b -- ^ arg

unwrap :: forall a b.
(Ix a, Integral a, Ord b, Floating b) =>
b -> Array a b -> Array a b
unwrap b
eps Array a b
phi = forall i e. Ix i => (i, i) -> [e] -> Array i e
listArray (a, a)
b [ Array a b
phiforall i e. Ix i => Array i e -> i -> e
!a
i forall a. Num a => a -> a -> a
+ b
2 forall a. Num a => a -> a -> a
* forall a. Floating a => a
pi forall a. Num a => a -> a -> a
* Array a b
rforall i e. Ix i => Array i e -> i -> e
!a
i | a
i <- forall a. Ix a => (a, a) -> [a]
range (a, a)
b ]
    where r :: Array a b
r = forall i e. Ix i => (i, i) -> [e] -> Array i e
listArray (a, a)
b [ a -> b
ri a
i | a
i <- forall a. Ix a => (a, a) -> [a]
range (a, a)
b ]
          ri :: a -> b
ri a
0 = b
0
	  ri a
i | Array a b
phiforall i e. Ix i => Array i e -> i -> e
!a
i forall a. Num a => a -> a -> a
- Array a b
phiforall i e. Ix i => Array i e -> i -> e
!(a
iforall a. Num a => a -> a -> a
-a
1) forall a. Ord a => a -> a -> Bool
>  (b
2forall a. Num a => a -> a -> a
*forall a. Floating a => a
piforall a. Num a => a -> a -> a
-b
eps) = Array a b
rforall i e. Ix i => Array i e -> i -> e
!(a
iforall a. Num a => a -> a -> a
-a
1) forall a. Num a => a -> a -> a
- b
1
	       | Array a b
phiforall i e. Ix i => Array i e -> i -> e
!a
i forall a. Num a => a -> a -> a
- Array a b
phiforall i e. Ix i => Array i e -> i -> e
!(a
iforall a. Num a => a -> a -> a
-a
1) forall a. Ord a => a -> a -> Bool
< -(b
2forall a. Num a => a -> a -> a
*forall a. Floating a => a
piforall a. Num a => a -> a -> a
-b
eps) = Array a b
rforall i e. Ix i => Array i e -> i -> e
!(a
iforall a. Num a => a -> a -> a
-a
1) forall a. Num a => a -> a -> a
+ b
1
	       | Bool
otherwise                       = Array a b
rforall i e. Ix i => Array i e -> i -> e
!(a
iforall a. Num a => a -> a -> a
-a
1)
	  b :: (a, a)
b = forall i e. Array i e -> (i, i)
bounds Array a b
phi