Modulematrices-0.5.0Haskell2010

Data.Matrix

Contents

Accessors
length information
Indexing
Construction
Conversions
Mapping
Monadic mapping
Zipping
Monadic Zipping
Unzipping
Monadic sequencing
Mutable matrix

Synopsis

type Matrix
value dim
value rows
value cols
value unsafeIndex
value !
value takeRow
value takeColumn
value takeDiag
value unsafeFromVector
value fromVector
value matrix
value fromList
value fromLists
value fromRows
value fromColumns
value empty
value flatten
value toRows
value toColumns
value toList
value toLists
value tr
value subMatrix
value ident
value diag
value diagRect
value fromBlocks
value isSymmetric
value force
value foldl
value map
value imap
value mapM
value imapM
value mapM_
value imapM_
value forM
value forM_
value zipWith
value zipWith3
value zipWith4
value zipWith5
value zipWith6
value izipWith
value izipWith3
value izipWith4
value izipWith5
value izipWith6
value zip
value zip3
value zip4
value zip5
value zip6
value zipWithM
value zipWithM_
value unzip
value unzip3
value unzip4
value unzip5
value unzip6
value sequence
value sequence_
value generate
value thaw
value unsafeThaw
value freeze
value unsafeFreeze
value create

Packagematrices-0.5.0
Exports69
LanguageHaskell2010
LicenceBSD-3-Clause
SourceMatrix.hs

typetype Matrix = Matrix Vector

Accessors

length information

valuedim :: Context a => Matrix a -> (Int, Int)

valuerows :: Context a => Matrix a -> Int

valuecols :: Context a => Matrix a -> Int

Indexing

valueunsafeIndex :: Context a => Matrix a -> (Int, Int) -> a

value(!) :: Context a => Matrix a -> (Int, Int) -> a

valuetakeRow :: Context a => Matrix a -> Int -> Vector a

valuetakeColumn :: Context a => Matrix a -> Int -> Vector a

valuetakeDiag :: Context a => Matrix a -> Vector a

Construction

valueunsafeFromVector :: Context a => (Int, Int) -> Vector a -> Matrix a

valuefromVector :: Context a => (Int, Int) -> Vector a -> Matrix a

valuematrix :: Context a => Int -> [a] -> Matrix a

Source#

O(m*n) Matrix construction

valuefromList :: Context a => (Int, Int) -> [a] -> Matrix a

valuefromLists :: Context a => [[a]] -> Matrix a

Source#

O(m*n) Create matrix from list of lists, it doesn't check if the list of list is a valid matrix

valuefromRows :: Context a => [Vector a] -> Matrix a

Source#

O(m*n) Create matrix from rows

valuefromColumns :: Context a => [Vector a] -> Matrix a

Source#

O(m*n) Create matrix from columns

valueempty :: Context a => Matrix a

Conversions

valueflatten :: Context a => Matrix a -> Vector a

valuetoRows :: Context a => Matrix a -> [Vector a]

Source#

O(m) Return the rows

valuetoColumns :: Context a => Matrix a -> [Vector a]

valuetoList :: Context a => Matrix a -> [a]

Source#

O(m*n) Create a list by concatenating rows

valuetoLists :: Context a => Matrix a -> [[a]]

Source#

O(m*n) List of lists

valuetr :: Context a => Matrix a -> Matrix a

Source#

O(m*n) Matrix transpose

valuesubMatrix

:: Context a
=> (Int, Int)
upper left corner of the submatrix
-> (Int, Int)
bottom right corner of the submatrix
-> Matrix a
-> Matrix a

Source#

O(1) Extract sub matrix

valueident :: (Context a, Num a) => Int -> Matrix a

Source#

O(m*n) Create an identity matrix

valuediag

:: (Context a, Num a, Foldable t)
=> t a
diagonal
-> Matrix a

Source#

O(m*n) Create a square matrix with given diagonal, other entries default to 0

valuediagRect

:: (Context a, Foldable t)
=> a
default value
-> (Int, Int)
-> t a
diagonal
-> Matrix a

Source#

O(m*n) Create a rectangular matrix with default values and given diagonal

valuefromBlocks

:: Context a
=> a
default value
-> [[Matrix a]]
-> Matrix a

valueisSymmetric :: (Context a, Eq a) => Matrix a -> Bool

valueforce :: Context a => Matrix a -> Matrix a

valuefoldl :: Context b => (a -> b -> a) -> a -> Matrix b -> a

Mapping

valuemap :: (Context a, Context b) => (a -> b) -> Matrix a -> Matrix b

valueimap

:: (Context a, Context b)
=> (Int, Int) -> a -> b
-> Matrix a
-> Matrix b

Monadic mapping

valuemapM

:: (Context a, Context b, Monad m)
=> a -> m b
-> Matrix a
-> m (Matrix b)

valueimapM

:: (Context a, Context b, Monad m)
=> (Int, Int) -> a -> m b
-> Matrix a
-> m (Matrix b)

Source#

O(m*n) Apply the monadic action to every element and its index, yielding a matrix of results.

valuemapM_ :: (Context a, Monad m) => (a -> m b) -> Matrix a -> m ()

valueimapM_

:: (Context a, Monad m)
=> (Int, Int) -> a -> m b
-> Matrix a
-> m ()

Source#

O(m*n) Apply the monadic action to every element and its index, ignoring the results.

valueforM

:: (Context a, Context b, Monad m)
=> Matrix a
-> a -> m b
-> m (Matrix b)

valueforM_ :: (Context a, Monad m) => Matrix a -> (a -> m b) -> m ()

Zipping

valuezipWith

:: (Context a, Context b, Context c)
=> a -> b -> c
-> Matrix a
-> Matrix b
-> Matrix c

valuezipWith3

:: (Context a, Context b, Context c, Context d)
=> a -> b -> c -> d
-> Matrix a
-> Matrix b
-> Matrix c
-> Matrix d

valuezipWith4

:: (Context a, Context b, Context c, Context d, Context e)
=> a -> b -> c -> d -> e
-> Matrix a
-> Matrix b
-> Matrix c
-> Matrix d
-> Matrix e

valuezipWith5

:: (Context a, Context b, Context c, Context d, Context e, Context f)
=> a -> b -> c -> d -> e -> f
-> Matrix a
-> Matrix b
-> Matrix c
-> Matrix d
-> Matrix e
-> Matrix f

valuezipWith6

:: (Context a, Context b, Context c, Context d, Context e, Context f, Context g)
=> a -> b -> c -> d -> e -> f -> g
-> Matrix a
-> Matrix b
-> Matrix c
-> Matrix d
-> Matrix e
-> Matrix f
-> Matrix g

valueizipWith

:: (Context a, Context b, Context c)
=> (Int, Int) -> a -> b -> c
-> Matrix a
-> Matrix b
-> Matrix c

valueizipWith3

:: (Context a, Context b, Context c, Context d)
=> (Int, Int) -> a -> b -> c -> d
-> Matrix a
-> Matrix b
-> Matrix c
-> Matrix d

valueizipWith4

:: (Context a, Context b, Context c, Context d, Context e)
=> (Int, Int) -> a -> b -> c -> d -> e
-> Matrix a
-> Matrix b
-> Matrix c
-> Matrix d
-> Matrix e

valueizipWith5

:: (Context a, Context b, Context c, Context d, Context e, Context f)
=> (Int, Int) -> a -> b -> c -> d -> e -> f
-> Matrix a
-> Matrix b
-> Matrix c
-> Matrix d
-> Matrix e
-> Matrix f

valueizipWith6

:: (Context a, Context b, Context c, Context d, Context e, Context f, Context g)
=> (Int, Int) -> a -> b -> c -> d -> e -> f -> g
-> Matrix a
-> Matrix b
-> Matrix c
-> Matrix d
-> Matrix e
-> Matrix f
-> Matrix g

valuezip

:: (Context a, Context b, Context (a, b))
=> Matrix a
-> Matrix b
-> Matrix (a, b)

valuezip3

:: (Context a, Context b, Context c, Context (a, b, c))
=> Matrix a
-> Matrix b
-> Matrix c
-> Matrix (a, b, c)

valuezip4

:: (Context a, Context b, Context c, Context d, Context (a, b, c, d))
=> Matrix a
-> Matrix b
-> Matrix c
-> Matrix d
-> Matrix (a, b, c, d)

valuezip5

:: (Context a, Context b, Context c, Context d, Context e, Context (a, b, c, d, e))
=> Matrix a
-> Matrix b
-> Matrix c
-> Matrix d
-> Matrix e
-> Matrix (a, b, c, d, e)

valuezip6

:: (Context a, Context b, Context c, Context d, Context e, Context f, Context (a, b, c, d, e, f))
=> Matrix a
-> Matrix b
-> Matrix c
-> Matrix d
-> Matrix e
-> Matrix f
-> Matrix (a, b, c, d, e, f)

Monadic Zipping

valuezipWithM

:: (Context a, Context b, Context c, Monad m)
=> a -> b -> m c
-> Matrix a
-> Matrix b
-> m (Matrix c)

valuezipWithM_

:: (Context a, Context b, Monad m)
=> a -> b -> m c
-> Matrix a
-> Matrix b
-> m ()

Unzipping

valueunzip

:: (Context a, Context b, Context (a, b))
=> Matrix (a, b)
-> (Matrix a, Matrix b)

valueunzip3

:: (Context a, Context b, Context c, Context (a, b, c))
=> Matrix (a, b, c)
-> (Matrix a, Matrix b, Matrix c)

valueunzip4

:: (Context a, Context b, Context c, Context d, Context (a, b, c, d))
=> Matrix (a, b, c, d)
-> (Matrix a, Matrix b, Matrix c, Matrix d)

valueunzip5

:: (Context a, Context b, Context c, Context d, Context e, Context (a, b, c, d, e))
=> Matrix (a, b, c, d, e)
-> (Matrix a, Matrix b, Matrix c, Matrix d, Matrix e)

valueunzip6

:: (Context a, Context b, Context c, Context d, Context e, Context f, Context (a, b, c, d, e, f))
=> Matrix (a, b, c, d, e, f)
-> (Matrix a, Matrix b, Matrix c, Matrix d, Matrix e, Matrix f)

Monadic sequencing

valuesequence :: Monad m => Matrix (m a) -> m (Matrix a)

valuesequence_ :: Monad m => Matrix (m a) -> m ()

valuegenerate :: Context a => (Int, Int) -> ((Int, Int) -> a) -> Matrix a

Mutable matrix

valuethaw :: (Context a, PrimMonad s) => Matrix a -> s (MMatrix (PrimState s) a)

valueunsafeThaw

:: (Context a, PrimMonad s)
=> Matrix a
-> s (MMatrix (PrimState s) a)

valuefreeze

:: (Context a, PrimMonad s)
=> MMatrix (PrimState s) a
-> s (Matrix a)

valueunsafeFreeze

:: (Context a, PrimMonad s)
=> MMatrix (PrimState s) a
-> s (Matrix a)

valuecreate :: Context a => (forall s. ST s (MMatrix s a)) -> Matrix a