hmatrix-0.17.0.2: Numeric Linear Algebra

Copyright(c) Alberto Ruiz 2014
LicenseBSD3
MaintainerAlberto Ruiz
Stabilityprovisional
Safe HaskellNone
LanguageHaskell98

Numeric.LinearAlgebra.Devel

Contents

Description

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

Synopsis

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 Source #

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 Source #

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

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

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

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

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

unsafeMatrixToVector :: Matrix a -> Vector a Source #

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.

FFI tools

See examples/devel in the repository.

class TransArray c where Source #

Minimal complete definition

apply, applyRaw

Associated Types

type Trans c b Source #

type TransRaw c b Source #

Methods

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

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

Instances

Storable t => TransArray (Vector t) Source # 

Associated Types

type Trans (Vector t) b :: * Source #

type TransRaw (Vector t) b :: * Source #

Methods

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

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

Storable t => TransArray (Matrix t) Source # 

Associated Types

type Trans (Matrix t) b :: * Source #

type TransRaw (Matrix t) b :: * Source #

Methods

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

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

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

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

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 () Source #

check the error code

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

postfix function application (flip ($))

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

postfix error code check

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

access to Vector elements without range checking

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

fi :: Int -> CInt Source #

specialized fromIntegral

ti :: CInt -> Int Source #

specialized fromIntegral

ST

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

Mutable Vectors

data STVector s t Source #

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

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

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

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

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

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

Mutable Matrices

data STMatrix s t Source #

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

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

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

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

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

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

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

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

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

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

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

data Slice s t Source #

r0 c0 height width

Constructors

Slice (STMatrix s t) Int Int Int Int 

Unsafe functions

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

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

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

Special maps and zips

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

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

zip for Vectors

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

zipWith for Vectors

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

unzip for Vectors

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

unzipWith for Vectors

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

monadic map over Vectors the monad m must be strict

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

monadic map over Vectors

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

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 () Source #

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

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

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

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

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

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

>>> 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) Source #

>>> 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 () Source #

>>> 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 Source #

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 Source #

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 Source #

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 Source #

Constructors

CSR 

Instances

Show CSR Source # 

Methods

showsPrec :: Int -> CSR -> ShowS #

show :: CSR -> String #

showList :: [CSR] -> ShowS #

data GMatrix Source #

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

SparseC 

Fields

Diag 

Fields

Dense 

Fields

Misc