move successive to Tests and examples

6 files changed, 118 insertions, 78 deletions

diff --git a/CHANGES b/CHANGES
index be9dcd0..cc05934 100644
--- a/CHANGES
+++ b/CHANGES
@@ -1,18 +1,20 @@
 0.10.0.0
 ========
 
-- diagRect admits diagonal vectors of any length without producing an error,
-  and takes an additional argument for the off-diagonal elements.
+- Module reorganization
 
-- optimiseMult
+- Support for Float and Complex Float elements (excluding LAPACK computations)
 
-- module reorganization, introducing Numeric.Container
+- Binary instances for Vector and Matrix
 
-- vectorMapM, unzipVectorWith
+- optimiseMult
 
-- Support for Float and Complex Float elements (excluding LAPACK computations)
+- mapVectorM, mapVectorWithIndexM, unzipVectorWith, and related functions.
 
-- Binary instances for Vector and Matrix
+- diagRect admits diagonal vectors of any length without producing an error,
+  and takes an additional argument for the off-diagonal elements.
+
+- different signatures in some functions
 
 0.9.3.0
 =======
diff --git a/THANKS b/THANKS
index 22ecc05..916cee3 100644
--- a/THANKS
+++ b/THANKS
@@ -4,7 +4,7 @@ and all the people in the Haskell mailing lists for their help.
 I am particularly grateful to Vivian McPhail for his excellent
 contributions: improved configure.hs, Binary instances for
 Vector and Matrix, support for Float and Complex Float elements,
-Vectors typeclass, monadic vectorMapM, and many other improvements.
+module reorganization, monadic mapVectorM, and many other improvements.
 
 - Nico Mahlo discovered a bug in the eigendecomposition wrapper.
 
diff --git a/examples/monadic.hs b/examples/monadic.hs
index b933de9..7c6e0f4 100644
--- a/examples/monadic.hs
+++ b/examples/monadic.hs
@@ -1,18 +1,17 @@
 -- monadic computations
 -- (contributed by Vivian McPhail)
 
-import Numeric.Container
-import Control.Monad.State
+import Numeric.LinearAlgebra
+import Control.Monad.State.Strict
 import Control.Monad.Maybe
+import Foreign.Storable(Storable)
+import System.Random(randomIO)
 
 -------------------------------------------
 
 -- an instance of MonadIO, a monad transformer
 type VectorMonadT = StateT Int IO
 
-v :: Vector Int
-v = 10 |> [0..]
-
 test1 :: Vector Int -> IO (Vector Int)
 test1 = mapVectorM $ \x -> do
     putStr $ (show x) ++ " "
@@ -69,10 +68,34 @@ isMonotoneIncreasing v =
         Nothing -> False
         Just _  -> True
 
-w = fromList ([1..10]++[10,9..1]) :: Vector Double
 
 -------------------------------------------
 
+-- | apply a test to successive elements of a vector, evaluates to true iff test passes for all pairs
+successive_ :: Storable a => (a -> a -> Bool) -> Vector a -> Bool
+successive_ t v = maybe False (\_ -> True) $ evalState (runMaybeT (mapVectorM_ step (subVector 1 (dim v - 1) v))) (v @> 0)
+   where step e = do
+                  ep <- lift $ get
+                  if t e ep
+                     then lift $ put e
+                     else (fail "successive_ test failed")
+
+-- | operate on successive elements of a vector and return the resulting vector, whose length 1 less than that of the input
+successive :: (Storable a, Storable b) => (a -> a -> b) -> Vector a -> Vector b
+successive f v = evalState (mapVectorM step (subVector 1 (dim v - 1) v)) (v @> 0)
+   where step e = do
+                  ep <- get
+                  put e
+                  return $ f ep e
+
+-------------------------------------------
+
+v :: Vector Int
+v = 10 |> [0..]
+
+w = fromList ([1..10]++[10,9..1]) :: Vector Double
+
+
 main = do
     v' <- test1 v
     putStrLn ""
@@ -84,7 +107,12 @@ main = do
     putStrLn ""
     evalStateT (indexPlusSum v) 0
     putStrLn "-----------------------"
+    mapVectorM_ print v
+    print =<< (mapVectorM (const randomIO) v :: IO (Vector Double))
+    print =<< (mapVectorM (\a -> fmap (+a) randomIO) (5|>[0,100..1000]) :: IO (Vector Double))
+    putStrLn "-----------------------"
     print $ isMonotoneIncreasing w
     print $ isMonotoneIncreasing (subVector 0 7 w)
     print $ successive_ (>) v
     print $ successive_ (>) w
+    print $ successive (+) v
diff --git a/hmatrix.cabal b/hmatrix.cabal
index fb5ed05..a98d984 100644
--- a/hmatrix.cabal
+++ b/hmatrix.cabal
@@ -11,11 +11,22 @@ Description:        Purely functional interface to basic linear algebra
                     and other numerical computations, internally implemented using
                     GSL, BLAS and LAPACK.
                     .
-                    See also hmatrix-special and hmatrix-glpk.
+                    The Linear Algebra API is organized as follows:
+                    .
+                    - "Data.Packed": structure manipulation
+                    .
+                    - "Numeric.Container": simple numeric functions
+                    .
+                    - "Numeric.LinearAlgebra.Algorithms": matrix computations
+                    .
+                    - "Numeric.LinearAlgebra": everything + instances of standard Haskell numeric classes
+                    .
+                    See also @hmatrix-special@ for GSL special functions
+                    and @hmatrix-glpk@ for linear programming (simplex).
 Category:           Math
 tested-with:        GHC ==6.10.4, GHC ==6.12.1
 
-cabal-version:      >=1.2
+cabal-version:      >=1.6
 
 build-type:         Custom
 
@@ -45,7 +56,7 @@ extra-source-files: examples/tests.hs
                     examples/devel/ej2/functions.c
                     examples/Real.hs
                     examples/vector.hs
-                    examples/vector-map.hs
+                    examples/monadic.hs
 
 extra-source-files: lib/Numeric/LinearAlgebra/LAPACK/lapack-aux.h,
                     lib/Numeric/LinearAlgebra/LAPACK/clapack.h
@@ -120,7 +131,7 @@ library
                         lib/Numeric/GSL/gsl-aux.c
 
     if flag(vector)
-       Build-Depends:   vector
+       Build-Depends:   vector >= 0.7
        cpp-options:     -DVECTOR
 
     if flag(tests)
@@ -165,7 +176,6 @@ library
     extra-libraries:
     extra-lib-dirs:
 
-    source-repository head
-        type:     darcs
-        location: http://code.haskell.org/hmatrix
-
+source-repository head
+    type:     darcs
+    location: http://code.haskell.org/hmatrix
diff --git a/lib/Data/Packed/Vector.hs b/lib/Data/Packed/Vector.hs
index e79e237..8b1e813 100644
--- a/lib/Data/Packed/Vector.hs
+++ b/lib/Data/Packed/Vector.hs
@@ -22,8 +22,7 @@ module Data.Packed.Vector (
     subVector, takesV, join,
     mapVector, zipVector, zipVectorWith, unzipVector, unzipVectorWith,
     mapVectorM, mapVectorM_, mapVectorWithIndexM, mapVectorWithIndexM_,
-    foldLoop, foldVector, foldVectorG, foldVectorWithIndex,
-    successive_, successive
+    foldLoop, foldVector, foldVectorG, foldVectorWithIndex
 ) where
 
 import Data.Packed.Internal.Vector
@@ -84,54 +83,3 @@ unzipVector :: (Storable a, Storable b, Storable (a,b)) => Vector (a,b) -> (Vect
 unzipVector = unzipVectorWith id
 
 -------------------------------------------------------------------
-
-newtype State s a = State { runState :: s -> (a,s) }
-
-instance Monad (State s) where
-    return a = State $ \s -> (a,s)
-    m >>= f = State $ \s -> let (a,s') = runState m s
-                            in runState (f a) s'
-
-state_get :: State s s
-state_get = State $ \s -> (s,s)
-
-state_put :: s -> State s ()
-state_put s = State $ \_ -> ((),s)
-
-evalState :: State s a -> s -> a
-evalState m s = let (a,s') = runState m s
-                in seq s' a
-
-newtype MaybeT m a = MaybeT { runMaybeT :: m (Maybe a) }
-
-instance Monad m => Monad (MaybeT m) where
-    return a = MaybeT $ return $ Just a
-    m >>= f  = MaybeT $ do
-                        res <- runMaybeT m
-                        case res of
-                                 Nothing -> return Nothing
-                                 Just r  -> runMaybeT (f r)
-    fail _   = MaybeT $ return Nothing
-
-lift_maybe m = MaybeT $ do
-                        res <- m
-                        return $ Just res
-
--- | apply a test to successive elements of a vector, evaluates to true iff test passes for all pairs
-successive_ :: Storable a => (a -> a -> Bool) -> Vector a -> Bool
-successive_ t v = maybe False (\_ -> True) $ evalState (runMaybeT (mapVectorM_ step (subVector 1 (dim v - 1) v))) (v @> 0)
-   where step e = do
-                  ep <- lift_maybe $ state_get
-                  if t e ep
-                     then lift_maybe $ state_put e
-                     else (fail "successive_ test failed")
-
--- | operate on successive elements of a vector and return the resulting vector, whose length 1 less than that of the input
-successive :: (Storable a, Storable b) => (a -> a -> b) -> Vector a -> Vector b
-successive f v = evalState (mapVectorM step (subVector 1 (dim v - 1) v)) (v @> 0)
-   where step e = do
-                  ep <- state_get
-                  state_put e
-                  return $ f ep e
-
--------------------------------------------------------------------
diff --git a/lib/Numeric/LinearAlgebra/Tests.hs b/lib/Numeric/LinearAlgebra/Tests.hs
index 630ba91..093e4ef 100644
--- a/lib/Numeric/LinearAlgebra/Tests.hs
+++ b/lib/Numeric/LinearAlgebra/Tests.hs
@@ -26,7 +26,7 @@ import Numeric.LinearAlgebra
 import Numeric.LinearAlgebra.LAPACK
 import Numeric.LinearAlgebra.Tests.Instances
 import Numeric.LinearAlgebra.Tests.Properties
-import Test.HUnit hiding ((~:),test,Testable)
+import Test.HUnit hiding ((~:),test,Testable,State)
 import System.Info
 import Data.List(foldl1')
 import Numeric.GSL
@@ -300,8 +300,60 @@ conjuTest m = mapVector conjugate (flatten (trans m)) == flatten (ctrans m)
 
 ---------------------------------------------------------------------
 
-succTest = utest "successive" $ successive_ (>) (fromList [1 :: Double,2,3,4]) == True
-                             && successive_ (<) (fromList [1 :: Double,3,2,4]) == False
+newtype State s a = State { runState :: s -> (a,s) }
+
+instance Monad (State s) where
+    return a = State $ \s -> (a,s)
+    m >>= f = State $ \s -> let (a,s') = runState m s
+                            in runState (f a) s'
+
+state_get :: State s s
+state_get = State $ \s -> (s,s)
+
+state_put :: s -> State s ()
+state_put s = State $ \_ -> ((),s)
+
+evalState :: State s a -> s -> a
+evalState m s = let (a,s') = runState m s
+                in seq s' a
+
+newtype MaybeT m a = MaybeT { runMaybeT :: m (Maybe a) }
+
+instance Monad m => Monad (MaybeT m) where
+    return a = MaybeT $ return $ Just a
+    m >>= f  = MaybeT $ do
+                        res <- runMaybeT m
+                        case res of
+                                 Nothing -> return Nothing
+                                 Just r  -> runMaybeT (f r)
+    fail _   = MaybeT $ return Nothing
+
+lift_maybe m = MaybeT $ do
+                        res <- m
+                        return $ Just res
+
+-- | apply a test to successive elements of a vector, evaluates to true iff test passes for all pairs
+--successive_ :: Storable a => (a -> a -> Bool) -> Vector a -> Bool
+successive_ t v = maybe False (\_ -> True) $ evalState (runMaybeT (mapVectorM_ step (subVector 1 (dim v - 1) v))) (v @> 0)
+   where step e = do
+                  ep <- lift_maybe $ state_get
+                  if t e ep
+                     then lift_maybe $ state_put e
+                     else (fail "successive_ test failed")
+
+-- | operate on successive elements of a vector and return the resulting vector, whose length 1 less than that of the input
+--successive :: (Storable a, Storable b) => (a -> a -> b) -> Vector a -> Vector b
+successive f v = evalState (mapVectorM step (subVector 1 (dim v - 1) v)) (v @> 0)
+   where step e = do
+                  ep <- state_get
+                  state_put e
+                  return $ f ep e
+
+
+succTest = utest "successive" $
+       successive_ (>) (fromList [1 :: Double,2,3,4]) == True
+    && successive_ (>) (fromList [1 :: Double,3,2,4]) == False
+    && successive (+) (fromList [1..10 :: Double]) == 9 |> [3,5,7,9,11,13,15,17,19]
 
 ---------------------------------------------------------------------