Merge branch 'oldmaster'

Commit which were missing after fixing problems with
HG<->git mirroring

Conflicts:
	.hgtags
	statistics.cabal

Author: Shimuuar

Statistics/Matrix.hs

@@ -1,3 +1,4 @@
+{-# LANGUAGE PatternGuards #-}
 -- |
 -- Module    : Statistics.Matrix
 -- Copyright : 2011 Aleksey Khudyakov, 2014 Bryan O'Sullivan
@@ -9,13 +10,25 @@
 -- we implement the necessary minimum here.
 
 module Statistics.Matrix
-    (
+    ( -- * Data types
       Matrix(..)
     , Vector
-    , fromList
+      -- * Conversion from/to lists/vectors
     , fromVector
+    , fromList
+    , fromRowLists
+    , fromRows
+    , fromColumns
     , toVector
     , toList
+    , toRows
+    , toColumns
+    , toRowLists
+      -- * Other
+    , generate
+    , generateSym
+    , ident
+    , diag
     , dimension
     , center
     , multiply
@@ -34,10 +47,21 @@ module Statistics.Matrix
     ) where
 
 import Prelude hiding (exponent, map, sum)
+import Control.Applicative ((<$>))
+import Control.Monad.ST
+import qualified Data.Vector.Unboxed as U
+import           Data.Vector.Unboxed   ((!))
+import qualified Data.Vector.Unboxed.Mutable as UM
+
 import Statistics.Function (for, square)
 import Statistics.Matrix.Types
+import Statistics.Matrix.Mutable  (unsafeNew,unsafeWrite,unsafeFreeze)
 import Statistics.Sample.Internal (sum)
-import qualified Data.Vector.Unboxed as U
+
+
+----------------------------------------------------------------
+-- Conversion to/from vectors/lists
+----------------------------------------------------------------
 
 -- | Convert from a row-major list.
 fromList :: Int                 -- ^ Number of rows.
@@ -46,6 +70,10 @@ fromList :: Int                 -- ^ Number of rows.
          -> Matrix
 fromList r c = fromVector r c . U.fromList
 
+-- | create a matrix from a list of lists, as rows
+fromRowLists :: [[Double]] -> Matrix
+fromRowLists = fromRows . fmap U.fromList
+
 -- | Convert from a row-major vector.
 fromVector :: Int               -- ^ Number of rows.
            -> Int               -- ^ Number of columns.
@@ -56,6 +84,22 @@ fromVector r c v
   | otherwise  = Matrix r c 0 v
   where len    = U.length v
 
+-- | create a matrix from a list of vectors, as rows
+fromRows :: [Vector] -> Matrix
+fromRows xs
+  | [] <- xs        = error "Statistics.Matrix.fromRows: empty list of rows!"
+  | any (/=nCol) ns = error "Statistics.Matrix.fromRows: row sizes do not match"
+  | nCol == 0       = error "Statistics.Matrix.fromRows: zero columns in matrix"
+  | otherwise       = fromVector nRow nCol (U.concat xs)
+  where
+    nCol:ns = U.length <$> xs
+    nRow    = length xs
+
+
+-- | create a matrix from a list of vectors, as columns
+fromColumns :: [Vector] -> Matrix
+fromColumns = transpose . fromRows
+
 -- | Convert to a row-major flat vector.
 toVector :: Matrix -> U.Vector Double
 toVector (Matrix _ _ _ v) = v
@@ -64,6 +108,78 @@ toVector (Matrix _ _ _ v) = v
 toList :: Matrix -> [Double]
 toList = U.toList . toVector
 
+-- | Convert to a list of lists, as rows
+toRowLists :: Matrix -> [[Double]]
+toRowLists (Matrix _ nCol _ v)
+  = chunks $ U.toList v
+  where
+    chunks [] = []
+    chunks xs = case splitAt nCol xs of
+      (rowE,rest) -> rowE : chunks rest
+
+
+-- | Convert to a list of vectors, as rows
+toRows :: Matrix -> [Vector]
+toRows (Matrix _ nCol _ v) = chunks v
+  where
+    chunks xs
+      | U.null xs = []
+      | otherwise = case U.splitAt nCol xs of
+          (rowE,rest) -> rowE : chunks rest
+
+-- | Convert to a list of vectors, as columns
+toColumns :: Matrix -> [Vector]
+toColumns = toRows . transpose
+
+
+
+----------------------------------------------------------------
+-- Other
+----------------------------------------------------------------
+
+-- | Generate matrix using function
+generate :: Int                 -- ^ Number of rows
+         -> Int                 -- ^ Number of columns
+         -> (Int -> Int -> Double)
+            -- ^ Function which takes /row/ and /column/ as argument.
+         -> Matrix
+generate nRow nCol f
+  = Matrix nRow nCol 0 $ U.generate (nRow*nCol) $ \i ->
+      let (r,c) = i `quotRem` nCol in f r c
+
+-- | Generate symmetric square matrix using function
+generateSym
+  :: Int                 -- ^ Number of rows and columns
+  -> (Int -> Int -> Double)
+     -- ^ Function which takes /row/ and /column/ as argument. It must
+     --   be symmetric in arguments: @f i j == f j i@
+  -> Matrix
+generateSym n f = runST $ do
+  m <- unsafeNew n n
+  for 0 n $ \r -> do
+    unsafeWrite m r r (f r r)
+    for (r+1) n $ \c -> do
+      let x = f r c
+      unsafeWrite m r c x
+      unsafeWrite m c r x
+  unsafeFreeze m
+
+
+-- | Create the square identity matrix with given dimensions.
+ident :: Int -> Matrix
+ident n = diag $ U.replicate n 1.0
+
+-- | Create a square matrix with given diagonal, other entries default to 0
+diag :: Vector -> Matrix
+diag v
+  = Matrix n n 0 $ U.create $ do
+      arr <- UM.replicate (n*n) 0
+      for 0 n $ \i ->
+        UM.unsafeWrite arr (i*n + i) (v ! i)
+      return arr
+  where
+    n = U.length v
+
 -- | Return the dimensions of this matrix, as a (row,column) pair.
 dimension :: Matrix -> (Int, Int)
 dimension (Matrix r c _ _) = (r, c)
@@ -125,6 +241,7 @@ unsafeIndex :: Matrix
             -> Double
 unsafeIndex = unsafeBounds U.unsafeIndex
 
+-- | Apply function to every element of matrix
 map :: (Double -> Double) -> Matrix -> Matrix
 map f (Matrix r c e v) = Matrix r c e (U.map f v)
 

Statistics/Matrix/Mutable.hs

@@ -12,6 +12,7 @@ module Statistics.Matrix.Mutable
     , replicate
     , thaw
     , bounds
+    , unsafeNew
     , unsafeFreeze
     , unsafeRead
     , unsafeWrite
@@ -37,6 +38,17 @@ thaw (Matrix r c e v) = MMatrix r c e <$> U.thaw v
 unsafeFreeze :: MMatrix s -> ST s Matrix
 unsafeFreeze (MMatrix r c e mv) = Matrix r c e <$> U.unsafeFreeze mv
 
+-- | Allocate new matrix. Matrix content is not initialized hence unsafe.
+unsafeNew :: Int                -- ^ Number of row
+          -> Int                -- ^ Number of columns
+          -> ST s (MMatrix s)
+unsafeNew r c
+  | r < 0     = error "Statistics.Matrix.Mutable.unsafeNew: negative number of rows"
+  | c < 0     = error "Statistics.Matrix.Mutable.unsafeNew: negative number of columns"
+  | otherwise = do
+      vec <- M.new (r*c)
+      return $ MMatrix r c 0 vec
+
 unsafeRead :: MMatrix s -> Int -> Int -> ST s Double
 unsafeRead mat r c = unsafeBounds mat r c M.unsafeRead
 {-# INLINE unsafeRead #-}