Documentation

Matrix representation suitable for GSL and LAPACK computations.

The elements are stored in a continuous memory array.

Supported matrix elements.

This class provides optimized internal operations for selected element types. It provides unoptimised defaults for any Storable type, so you can create instances simply as: instance Element Foo.

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.

The input list is explicitly truncated, so that it can safely be used with lists that are too long (like infinite lists).

Example:

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

Matrix transpose.

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 ]

Creates a vector by concatenation of rows. If the matrix is ColumnMajor, this operation requires a transpose.

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

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 ]

the inverse of fromLists

creates a Matrix of the specified size using the supplied function to to map the row/column position to the value at that row/column position.

> buildMatrix 3 4 (\(r,c) -> fromIntegral r * fromIntegral c)
(3><4)
 [ 0.0, 0.0, 0.0, 0.0, 0.0
 , 0.0, 1.0, 2.0, 3.0, 4.0
 , 0.0, 2.0, 4.0, 6.0, 8.0]

Hilbert matrix of order N:

hilb n = buildMatrix n n (\(i,j)->1/(fromIntegral i + fromIntegral j +1))

Reads a matrix position.

creates a 1-row matrix from a vector

creates a 1-column matrix from a vector

Create a matrix from a list of vectors. All vectors must have the same dimension, or dimension 1, which is are automatically expanded.

extracts the rows of a matrix as a list of vectors

Creates a matrix from a list of vectors, as columns

Creates a list of vectors from the columns of a matrix

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

Single row/column components are automatically expanded to match the corresponding common row and column:

@> let disp = putStr . dispf 2 > let vector xs = fromList xs :: Vector Double > let diagl = diag . vector > let rowm = asRow . vector

> disp $ fromBlocks [[ident 5, 7, rowm[10,20]], [3, diagl[1,2,3], 0]]

8x10 1 0 0 0 0 7 7 7 10 20 0 1 0 0 0 7 7 7 10 20 0 0 1 0 0 7 7 7 10 20 0 0 0 1 0 7 7 7 10 20 0 0 0 0 1 7 7 7 10 20 3 3 3 3 3 1 0 0 0 0 3 3 3 3 3 0 2 0 0 0 3 3 3 3 3 0 0 3 0 0@

create a block diagonal matrix

Partition a matrix into blocks with the given numbers of rows and columns. The remaining rows and columns are discarded.

Fully partition a matrix into blocks of the same size. If the dimensions are not a multiple of the given size the last blocks will be smaller.

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 ]

Reverse rows

Reverse columns

Extracts a submatrix from a matrix.

Creates a matrix with the first n rows of another matrix

Creates a copy of a matrix without the first n rows

Creates a matrix with the first n columns of another matrix

Creates a copy of a matrix without the first n columns

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

creates a rectangular diagonal matrix:

> diagRect 7 (fromList [10,20,30]) 4 5 :: Matrix Double
(4><5)
 [ 10.0,  7.0,  7.0, 7.0, 7.0
 ,  7.0, 20.0,  7.0, 7.0, 7.0
 ,  7.0,  7.0, 30.0, 7.0, 7.0
 ,  7.0,  7.0,  7.0, 7.0, 7.0 ]

extracts the diagonal from a rectangular matrix

ghci> mapMatrixWithIndex (\(i,j) v -> 100*v + 10*i + 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 ]

ghci> mapMatrixWithIndexM (\(i,j) v -> Just $ 100*v + 10*i + 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 ]

ghci> mapMatrixWithIndexM_ (\(i,j) v -> printf "m[%.0f,%.0f] = %.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

application of a vector function on the flattened matrix elements

application of a vector function on the flattened matrices elements

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