Numeric.LinearAlgebra.Devel

The library can be easily extended using the tools in this module.

FFI helpers

Sample usage, to upload a perspective matrix to a shader.

 glUniformMatrix4fv 0 1 (fromIntegral gl_TRUE) `appMatrix` perspective 0.01 100 (pi/2) (4/3)

app :: (a -> b) -> a -> b infixl 1

Only useful since it is left associated with a precedence of 1, unlike $, which is right associative. e.g.

someFunction
    `appMatrixLen` m
    `appVectorLen` v
    `app` other
    `app` arguments
    `app` go here

One could also write:

(someFunction 
    `appMatrixLen` m
    `appVectorLen` v) 
    other 
    arguments 
    (go here)

appVector :: Storable a => (Ptr a -> b) -> Vector a -> b infixl 1

appVectorLen :: Storable a => (CInt -> Ptr a -> b) -> Vector a -> b

appMatrix :: Element a => (Ptr a -> b) -> Matrix a -> b infixl 1

appMatrixLen :: Element a => (CInt -> CInt -> Ptr a -> b) -> Matrix a -> b

appMatrixRaw :: Storable a => (Ptr a -> b) -> Matrix a -> b infixl 1

appMatrixRawLen :: Element a => (CInt -> CInt -> Ptr a -> b) -> Matrix a -> b

unsafeMatrixToVector :: Matrix a -> Vector a

This will disregard the order of the matrix, and simply return it as-is. If the order of the matrix is RowMajor, this function is identical to flatten.

unsafeMatrixToForeignPtr :: Storable a => Matrix a -> (ForeignPtr a, Int)

FFI tools

See examples/devel in the repository.

createVector :: Storable a => Int -> IO (Vector a)

createMatrix :: Storable a => MatrixOrder -> Int -> Int -> IO (Matrix a)

class TransArray c where

Minimal complete definition

apply, applyRaw

Associated Types

type Trans c b

type TransRaw c b

Methods

apply :: Trans c b -> c -> b infixl 1

applyRaw :: TransRaw c b -> c -> b infixl 1

Instances

Storable t => TransArray (Vector t)

Associated Types

type Trans (Vector t) b :: *

type TransRaw (Vector t) b :: *

Methods

apply :: Trans (Vector t) b -> Vector t -> b

applyRaw :: TransRaw (Vector t) b -> Vector t -> b

Storable t => TransArray (Matrix t)

Associated Types

type Trans (Matrix t) b :: *

type TransRaw (Matrix t) b :: *

Methods

apply :: Trans (Matrix t) b -> Matrix t -> b

applyRaw :: TransRaw (Matrix t) b -> Matrix t -> b

data MatrixOrder

Constructors

RowMajor

ColumnMajor

Instances

Eq MatrixOrder

Methods

(==) :: MatrixOrder -> MatrixOrder -> Bool

(/=) :: MatrixOrder -> MatrixOrder -> Bool

Show MatrixOrder

Methods

showsPrec :: Int -> MatrixOrder -> ShowS

show :: MatrixOrder -> String

showList :: [MatrixOrder] -> ShowS

orderOf :: Matrix t -> MatrixOrder

cmat :: Element t => Matrix t -> Matrix t

fmat :: Element t => Matrix t -> Matrix t

matrixFromVector :: Storable t => MatrixOrder -> Int -> Int -> Vector t -> Matrix t

unsafeFromForeignPtr

Arguments

:: Storable a

=> ForeignPtr a

pointer

-> Int

offset

-> Int

length

-> Vector a

O(1) Create a vector from a ForeignPtr with an offset and a length.

The data may not be modified through the ForeignPtr afterwards.

If your offset is 0 it is more efficient to use unsafeFromForeignPtr0.

unsafeToForeignPtr :: Storable a => Vector a -> (ForeignPtr a, Int, Int)

O(1) Yield the underlying ForeignPtr together with the offset to the data and its length. The data may not be modified through the ForeignPtr.

check :: String -> IO CInt -> IO ()

check the error code

(//) :: x -> (x -> y) -> y infixl 0

postfix function application (flip ($))

(#|) :: IO CInt -> String -> IO () infixl 0

postfix error code check

at' :: Storable a => Vector a -> Int -> a

access to Vector elements without range checking

atM' :: Storable t => Matrix t -> Int -> Int -> t

fi :: Int -> CInt

specialized fromIntegral

ti :: CInt -> Int

specialized fromIntegral

ST

In-place manipulation inside the ST monad. See examples/inplace.hs in the repository.

Mutable Vectors

data STVector s t

newVector :: Storable t => t -> Int -> ST s (STVector s t)

thawVector :: Storable t => Vector t -> ST s (STVector s t)

freezeVector :: Storable t => STVector s t -> ST s (Vector t)

runSTVector :: Storable t => (forall s. ST s (STVector s t)) -> Vector t

readVector :: Storable t => STVector s t -> Int -> ST s t

writeVector :: Storable t => STVector s t -> Int -> t -> ST s ()

modifyVector :: Storable t => STVector s t -> Int -> (t -> t) -> ST s ()

liftSTVector :: Storable t => (Vector t -> a) -> STVector s t -> ST s a

Mutable Matrices

data STMatrix s t

newMatrix :: Storable t => t -> Int -> Int -> ST s (STMatrix s t)

thawMatrix :: Element t => Matrix t -> ST s (STMatrix s t)

freezeMatrix :: Element t => STMatrix s t -> ST s (Matrix t)

runSTMatrix :: Storable t => (forall s. ST s (STMatrix s t)) -> Matrix t

readMatrix :: Storable t => STMatrix s t -> Int -> Int -> ST s t

writeMatrix :: Storable t => STMatrix s t -> Int -> Int -> t -> ST s ()

modifyMatrix :: Storable t => STMatrix s t -> Int -> Int -> (t -> t) -> ST s ()

liftSTMatrix :: Element t => (Matrix t -> a) -> STMatrix s t -> ST s a

mutable :: Element t => (forall s. (Int, Int) -> STMatrix s t -> ST s u) -> Matrix t -> (Matrix t, u)

extractMatrix :: Element a => STMatrix t a -> RowRange -> ColRange -> ST s (Matrix a)

setMatrix :: Element t => STMatrix s t -> Int -> Int -> Matrix t -> ST s ()

rowOper :: (Num t, Element t) => RowOper t -> STMatrix s t -> ST s ()

data RowOper t

Constructors

AXPY t Int Int ColRange

SCAL t RowRange ColRange

SWAP Int Int ColRange

data RowRange

Constructors

AllRows

RowRange Int Int

Row Int

FromRow Int

data ColRange

Constructors

AllCols

ColRange Int Int

Col Int

FromCol Int

gemmm :: Element t => t -> Slice s t -> t -> Slice s t -> Slice s t -> ST s ()

data Slice s t

r0 c0 height width

Constructors

Slice (STMatrix s t) Int Int Int Int

Unsafe functions

newUndefinedVector :: Storable t => Int -> ST s (STVector s t)

unsafeReadVector :: Storable t => STVector s t -> Int -> ST s t

unsafeWriteVector :: Storable t => STVector s t -> Int -> t -> ST s ()

unsafeThawVector :: Storable t => Vector t -> ST s (STVector s t)

unsafeFreezeVector :: Storable t => STVector s t -> ST s (Vector t)

newUndefinedMatrix :: Storable t => MatrixOrder -> Int -> Int -> ST s (STMatrix s t)

unsafeReadMatrix :: Storable t => STMatrix s t -> Int -> Int -> ST s t

unsafeWriteMatrix :: Storable t => STMatrix s t -> Int -> Int -> t -> ST s ()

unsafeThawMatrix :: Storable t => Matrix t -> ST s (STMatrix s t)

unsafeFreezeMatrix :: Storable t => STMatrix s t -> ST s (Matrix t)

Special maps and zips

mapVectorWithIndex :: (Storable a, Storable b) => (Int -> a -> b) -> Vector a -> Vector b

zipVector :: (Storable a, Storable b, Storable (a, b)) => Vector a -> Vector b -> Vector (a, b)

zip for Vectors

zipVectorWith :: (Storable a, Storable b, Storable c) => (a -> b -> c) -> Vector a -> Vector b -> Vector c

zipWith for Vectors

unzipVector :: (Storable a, Storable b, Storable (a, b)) => Vector (a, b) -> (Vector a, Vector b)

unzip for Vectors

unzipVectorWith :: (Storable (a, b), Storable c, Storable d) => ((a, b) -> (c, d)) -> Vector (a, b) -> (Vector c, Vector d)

unzipWith for Vectors

mapVectorM :: (Storable a, Storable b, Monad m) => (a -> m b) -> Vector a -> m (Vector b)

monadic map over Vectors the monad m must be strict

mapVectorM_ :: (Storable a, Monad m) => (a -> m ()) -> Vector a -> m ()

monadic map over Vectors

mapVectorWithIndexM :: (Storable a, Storable b, Monad m) => (Int -> a -> m b) -> Vector a -> m (Vector b)

monadic map over Vectors with the zero-indexed index passed to the mapping function the monad m must be strict

mapVectorWithIndexM_ :: (Storable a, Monad m) => (Int -> a -> m ()) -> Vector a -> m ()

monadic map over Vectors with the zero-indexed index passed to the mapping function

foldLoop :: (Int -> t -> t) -> t -> Int -> t

foldVector :: Storable a => (a -> b -> b) -> b -> Vector a -> b

foldVectorG :: Storable t1 => (Int -> (Int -> t1) -> t -> t) -> t -> Vector t1 -> t

foldVectorWithIndex :: Storable a => (Int -> a -> b -> b) -> b -> Vector a -> b

mapMatrixWithIndex :: (Element a, Storable b) => ((Int, Int) -> a -> b) -> Matrix a -> Matrix b

>>> mapMatrixWithIndex (\(i,j) v -> 100*v + 10*fromIntegral i + fromIntegral j) (ident 3:: Matrix Double)
(3><3)
 [ 100.0,   1.0,   2.0
 ,  10.0, 111.0,  12.0
 ,  20.0,  21.0, 122.0 ]

mapMatrixWithIndexM :: (Element a, Storable b, Monad m) => ((Int, Int) -> a -> m b) -> Matrix a -> m (Matrix b)

>>> mapMatrixWithIndexM (\(i,j) v -> Just $ 100*v + 10*fromIntegral i + fromIntegral j) (ident 3:: Matrix Double)
Just (3><3)
 [ 100.0,   1.0,   2.0
 ,  10.0, 111.0,  12.0
 ,  20.0,  21.0, 122.0 ]

mapMatrixWithIndexM_ :: (Element a, Num a, Monad m) => ((Int, Int) -> a -> m ()) -> Matrix a -> m ()

>>> mapMatrixWithIndexM_ (\(i,j) v -> printf "m[%d,%d] = %.f\n" i j v :: IO()) ((2><3)[1 :: Double ..])
m[0,0] = 1
m[0,1] = 2
m[0,2] = 3
m[1,0] = 4
m[1,1] = 5
m[1,2] = 6

liftMatrix :: (Element a, Element b) => (Vector a -> Vector b) -> Matrix a -> Matrix b

application of a vector function on the flattened matrix elements

liftMatrix2 :: (Element t, Element a, Element b) => (Vector a -> Vector b -> Vector t) -> Matrix a -> Matrix b -> Matrix t

application of a vector function on the flattened matrices elements

liftMatrix2Auto :: (Element t, Element a, Element b) => (Vector a -> Vector b -> Vector t) -> Matrix a -> Matrix b -> Matrix t

A version of liftMatrix2 which automatically adapt matrices with a single row or column to match the dimensions of the other matrix.

Sparse representation

data CSR

Constructors

CSR

Fields

• csrVals :: Vector Double
• csrCols :: Vector CInt
• csrRows :: Vector CInt
• csrNRows :: Int
• csrNCols :: Int

Instances

Show CSR

Methods

showsPrec :: Int -> CSR -> ShowS

show :: CSR -> String

showList :: [CSR] -> ShowS

fromCSR :: CSR -> GMatrix

mkCSR :: AssocMatrix -> CSR

data GMatrix

General matrix with specialized internal representations for dense, sparse, diagonal, banded, and constant elements.

>>> let m = mkSparse [((0,999),1.0),((1,1999),2.0)]
>>> m
SparseR {gmCSR = CSR {csrVals = fromList [1.0,2.0],
                      csrCols = fromList [1000,2000],
                      csrRows = fromList [1,2,3],
                      csrNRows = 2,
                      csrNCols = 2000},
                      nRows = 2,
                      nCols = 2000}

>>> let m = mkDense (mat 2 [1..4])
>>> m
Dense {gmDense = (2><2)
 [ 1.0, 2.0
 , 3.0, 4.0 ], nRows = 2, nCols = 2}

Constructors

SparseR

Fields

• gmCSR :: CSR
• nRows :: Int
• nCols :: Int

SparseC

Fields

• gmCSC :: CSC
• nRows :: Int
• nCols :: Int

Diag

Fields

• diagVals :: Vector Double
• nRows :: Int
• nCols :: Int

Dense

Fields

• gmDense :: Matrix Double
• nRows :: Int
• nCols :: Int

Instances

Show GMatrix

Methods

showsPrec :: Int -> GMatrix -> ShowS

show :: GMatrix -> String

showList :: [GMatrix] -> ShowS

Transposable GMatrix GMatrix

Methods

tr :: GMatrix -> GMatrix

tr' :: GMatrix -> GMatrix

Misc

toByteString :: Storable t => Vector t -> ByteString

fromByteString :: Storable t => ByteString -> Vector t

showInternal :: Storable t => Matrix t -> IO ()