matrices 0.4.4 → 0.4.5

raw patch · 2 files changed

+38/−19 lines, 2 filesdep ~vectorPVP ok

version bump matches the API change (PVP)

Dependency ranges changed: vector

API changes (from Hackage documentation)

Files

• matrices.cabal +5/−10
• src/Data/Matrix/Dense/Generic.hs +33/−9

@@ -2,20 +2,17 @@ -- documentation, see http://haskell.org/cabal/users-guide/  name:                matrices-version:             0.4.4+version:             0.4.5 synopsis:            native matrix based on vector-description:         This library provide the APIs for creating, indexing,-                     modifying matrices (2d arrays), including dense and-                     sparse representations. The underling data-                     structure is vector.+description:         Pure Haskell matrix library, supporting creating, indexing,+                     and modifying dense/sparse matrices. license:             BSD3 license-file:        LICENSE author:              Kai Zhang maintainer:          kai@kzhang.org-copyright:           (c) 2015,2016 Kai Zhang+copyright:           (c) 2015-2017 Kai Zhang category:            Data build-type:          Simple--- extra-source-files: cabal-version:       >=1.10  library@@ -36,12 +33,10 @@    ghc-options: -Wall -funbox-strict-fields -  -- other-modules:-   build-depends:       base >=4.8 && <5     , deepseq-    , vector >=0.9+    , vector >=0.11     , primitive    hs-source-dirs:      src

@@ -53,11 +53,14 @@     , Data.Matrix.Dense.Generic.foldl      -- * Mapping-    , imap     , Data.Matrix.Dense.Generic.map+    , imap+     -- * Monadic mapping     , mapM+    , imapM     , mapM_+    , imapM_     , forM     , forM_ @@ -117,7 +120,7 @@  type instance MG.Mutable Matrix = MMatrix --- | row-major matrix supporting efficient slice+-- | Row-major matrix supporting efficient slice data Matrix v a = Matrix !Int    -- number of rows                          !Int    -- number of cols                          !Int    -- physical row dimension@@ -268,29 +271,50 @@ force m@(Matrix r c _ _ _) = MG.fromVector (r,c) . G.force . MG.flatten $ m {-# INLINE force #-} +map :: (G.Vector v a, G.Vector v b) => (a -> b) -> Matrix v a -> Matrix v b+map f m@(Matrix r c _ _ _) = MG.fromVector (r,c) $ G.map f . MG.flatten $ m+{-# INLINE map #-}+ imap :: (G.Vector v a, G.Vector v b) => ((Int, Int) -> a -> b) -> Matrix v a -> Matrix v b imap f m@(Matrix r c _ _ _) = MG.fromVector (r,c) $ G.imap f' . MG.flatten $ m   where     f' i = f (i `div` c, i `mod` c) {-# INLINE imap #-} -map :: (G.Vector v a, G.Vector v b) => (a -> b) -> Matrix v a -> Matrix v b-map f m@(Matrix r c _ _ _) = MG.fromVector (r,c) $ G.map f . MG.flatten $ m-{-# INLINE map #-}- foldl :: G.Vector v b => (a -> b -> a) -> a -> Matrix v b -> a foldl f acc m = G.foldl f acc . MG.flatten $ m {-# INLINE foldl #-} -mapM :: (G.Vector v a, G.Vector v b, Monad m) => (a -> m b) -> Matrix v a -> m (Matrix v b)-mapM f m@(Matrix r c _ _ _) = liftM (MG.fromVector (r,c)) . G.mapM f . MG.flatten $ m+mapM :: (G.Vector v a, G.Vector v b, Monad m)+     => (a -> m b) -> Matrix v a -> m (Matrix v b)+mapM f m@(Matrix r c _ _ _) = liftM (MG.fromVector (r,c)) $ G.mapM f $ MG.flatten m {-# INLINE mapM #-} +-- | O(m*n) Apply the monadic action to every element and its index,+-- yielding a matrix of results.+imapM :: (G.Vector v a, G.Vector v b, Monad m)+      => ((Int, Int) -> a -> m b) -> Matrix v a -> m (Matrix v b)+imapM f m@(Matrix r c _ _ _) = fmap (MG.fromVector (r,c)) $ G.imapM f' $+    MG.flatten m+  where+    f' i = f (i `div` c, i `mod` c)+{-# INLINE imapM #-}+ mapM_ :: (G.Vector v a, Monad m) => (a -> m b) -> Matrix v a -> m () mapM_ f = G.mapM_ f . MG.flatten {-# INLINE mapM_ #-} -forM :: (G.Vector v a, G.Vector v b, Monad m) => Matrix v a -> (a -> m b) -> m (Matrix v b)+-- | O(m*n) Apply the monadic action to every element and its index,+-- ignoring the results.+imapM_ :: (G.Vector v a, Monad m)+       => ((Int, Int) -> a -> m b) -> Matrix v a -> m ()+imapM_ f m@(Matrix _ c _ _ _) = G.imapM_ f' $ MG.flatten m+  where+    f' i = f (i `div` c, i `mod` c)+{-# INLINE imapM_ #-}++forM :: (G.Vector v a, G.Vector v b, Monad m)+     => Matrix v a -> (a -> m b) -> m (Matrix v b) forM = flip mapM {-# INLINE forM #-}