Data.Packed.Matrix

A Matrix representation suitable for numerical computations using LAPACK and GSL.

Documentation

class (Storable a, Floating a) => Element a

Auxiliary class.

Instances

Element Double

Element (Complex Double)

data Matrix t

Matrix representation suitable for GSL and LAPACK computations.

Instances

Container Matrix Double

(Linear Vector a, Container Matrix a) => Linear Matrix a

Joinable Vector Matrix

Joinable Matrix Vector

Joinable Matrix Matrix

Mul Vector Matrix Vector

Mul Matrix Vector Vector

Mul Matrix Matrix Matrix

Container Matrix (Complex Double)

(Eq a, Element a) => Eq (Matrix a)

(Linear Vector a, Floating (Vector a), Fractional (Matrix a)) => Floating (Matrix a)

(Linear Vector a, Fractional (Vector a), Num (Matrix a)) => Fractional (Matrix a)

(Linear Matrix a, Num (Vector a)) => Num (Matrix a)

(Element a, Read a) => Read (Matrix a)

(Show a, Element a) => Show (Matrix a)

(Element a, Arbitrary a) => Arbitrary (Matrix a)

Normed (Matrix Double)

Normed (Matrix (Complex Double))

rows :: Matrix t -> Int

cols :: Matrix t -> Int

(><) :: Element a => Int -> Int -> [a] -> Matrix a

An easy way to create a matrix:

> (2><3)[1..6]
(2><3)
 [ 1.0, 2.0, 3.0
 , 4.0, 5.0, 6.0 ]

This is the format produced by the instances of Show (Matrix a), which can also be used for input.

trans :: Matrix t -> Matrix t

Matrix transpose.

reshape :: Element t => Int -> Vector t -> Matrix t

Unsafe matrix access without range checking

Creates a matrix from a vector by grouping the elements in rows with the desired number of columns. (GNU-Octave groups by columns. To do it you can define reshapeF r = trans . reshape r where r is the desired number of rows.)

> reshape 4 (fromList [1..12])
(3><4)
 [ 1.0,  2.0,  3.0,  4.0
 , 5.0,  6.0,  7.0,  8.0
 , 9.0, 10.0, 11.0, 12.0 ]

flatten :: Element t => Matrix t -> Vector t

Creates a vector by concatenation of rows

> flatten (ident 3)
9 |> [1.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,1.0]

fromLists :: Element t => [[t]] -> Matrix t

Creates a Matrix from a list of lists (considered as rows).

> fromLists [[1,2],[3,4],[5,6]]
(3><2)
 [ 1.0, 2.0
 , 3.0, 4.0
 , 5.0, 6.0 ]

toLists :: Element t => Matrix t -> [[t]]

the inverse of Data.Packed.Matrix.fromLists

(@@>) :: Storable t => Matrix t -> (Int, Int) -> t

Reads a matrix position.

asRow :: Element a => Vector a -> Matrix a

creates a 1-row matrix from a vector

asColumn :: Element a => Vector a -> Matrix a

creates a 1-column matrix from a vector

fromRows :: Element t => [Vector t] -> Matrix t

creates a Matrix from a list of vectors

toRows :: Element t => Matrix t -> [Vector t]

extracts the rows of a matrix as a list of vectors

fromColumns :: Element t => [Vector t] -> Matrix t

Creates a matrix from a list of vectors, as columns

toColumns :: Element t => Matrix t -> [Vector t]

Creates a list of vectors from the columns of a matrix

fromBlocks :: Element t => [[Matrix t]] -> Matrix t

Creates a matrix from blocks given as a list of lists of matrices:

> let a = diag $ fromList [5,7,2]
> let b = reshape 4 $ constant (-1) 12
> fromBlocks [[a,b],[b,a]]
(6><7)
 [  5.0,  0.0,  0.0, -1.0, -1.0, -1.0, -1.0
 ,  0.0,  7.0,  0.0, -1.0, -1.0, -1.0, -1.0
 ,  0.0,  0.0,  2.0, -1.0, -1.0, -1.0, -1.0
 , -1.0, -1.0, -1.0, -1.0,  5.0,  0.0,  0.0
 , -1.0, -1.0, -1.0, -1.0,  0.0,  7.0,  0.0
 , -1.0, -1.0, -1.0, -1.0,  0.0,  0.0,  2.0 ]

repmat :: Element t => Matrix t -> Int -> Int -> Matrix t

creates matrix by repetition of a matrix a given number of rows and columns

> repmat (ident 2) 2 3 :: Matrix Double
(4><6)
 [ 1.0, 0.0, 1.0, 0.0, 1.0, 0.0
 , 0.0, 1.0, 0.0, 1.0, 0.0, 1.0
 , 1.0, 0.0, 1.0, 0.0, 1.0, 0.0
 , 0.0, 1.0, 0.0, 1.0, 0.0, 1.0 ]

flipud :: Element t => Matrix t -> Matrix t

Reverse rows

fliprl :: Element t => Matrix t -> Matrix t

Reverse columns

subMatrix

Arguments

:: Element a

=> (Int, Int)

(r0,c0) starting position

-> (Int, Int)

(rt,ct) dimensions of submatrix

-> Matrix a

input matrix

-> Matrix a

result

Extracts a submatrix from a matrix.

takeRows :: Element t => Int -> Matrix t -> Matrix t

Creates a matrix with the first n rows of another matrix

dropRows :: Element t => Int -> Matrix t -> Matrix t

Creates a copy of a matrix without the first n rows

takeColumns :: Element t => Int -> Matrix t -> Matrix t

Creates a matrix with the first n columns of another matrix

dropColumns :: Element t => Int -> Matrix t -> Matrix t

Creates a copy of a matrix without the first n columns

extractRows :: Element t => [Int] -> Matrix t -> Matrix t

rearranges the rows of a matrix according to the order given in a list of integers.

ident :: Element a => Int -> Matrix a

creates the identity matrix of given dimension

diag :: Element a => Vector a -> Matrix a

Creates a square matrix with a given diagonal.

diagRect :: (Element t, Num t) => Vector t -> Int -> Int -> Matrix t

creates a rectangular diagonal matrix

> diagRect (constant 5 3) 3 4 :: Matrix Double
(3><4)
 [ 5.0, 0.0, 0.0, 0.0
 , 0.0, 5.0, 0.0, 0.0
 , 0.0, 0.0, 5.0, 0.0 ]

takeDiag :: Element t => Matrix t -> Vector t

extracts the diagonal from a rectangular matrix

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

format :: Element t => String -> (t -> String) -> Matrix t -> String

Creates a string from a matrix given a separator and a function to show each entry. Using this function the user can easily define any desired display function:

import Text.Printf(printf)

disp = putStrLn . format "  " (printf "%.2f")

readMatrix :: String -> Matrix Double

creates a matrix from a table of numbers.

fromFile :: FilePath -> (Int, Int) -> IO (Matrix Double)

loads a matrix efficiently from formatted ASCII text file (the number of rows and columns must be known in advance).

fromArray2D :: Element e => Array (Int, Int) e -> Matrix e