Data.Matrix

Type of matrices.

Elements can be of any type. Rows and columns are indexed starting by 1. This means that, if m :: Matrix a and i,j :: Int, then m ! (i,j) is the element in the i-th row and j-th column of m.

Display a matrix as a String using the Show instance of its elements.

Number of rows.

Number of columns.

O(rows*cols). Similar to force. It copies the matrix content dropping any extra memory.

Useful when using submatrix from a big matrix.

O(rows*cols). Generate a matrix from a generator function. Example of usage:

                                 (  1  0 -1 -2 )
                                 (  3  2  1  0 )
                                 (  5  4  3  2 )
matrix 4 4 $ \(i,j) -> 2*i - j = (  7  6  5  4 )

O(1). Represent a vector as a one row matrix.

O(1). Represent a vector as a one column matrix.

Create a matrix from a non-empty list given the desired size. The list must have at least rows*cols elements. An example:

                      ( 1 2 3 )
                      ( 4 5 6 )
fromList 3 3 [1..] =  ( 7 8 9 )

Create a matrix from a non-empty list of non-empty lists. Each list must have at least as many elements as the first list. Examples:

fromLists [ [1,2,3]      ( 1 2 3 )
          , [4,5,6]      ( 4 5 6 )
          , [7,8,9] ] =  ( 7 8 9 )

fromLists [ [1,2,3  ]     ( 1 2 3 )
          , [4,5,6,7]     ( 4 5 6 )
          , [8,9,0  ] ] = ( 8 9 0 )

Get the elements of a matrix stored in a list.

       ( 1 2 3 )
       ( 4 5 6 )
toList ( 7 8 9 ) = [1,2,3,4,5,6,7,8,9]

Get the elements of a matrix stored in a list of lists, where each list contains the elements of a single row.

        ( 1 2 3 )   [ [1,2,3]
        ( 4 5 6 )   , [4,5,6]
toLists ( 7 8 9 ) = , [7,8,9] ]

O(1). Get an element of a matrix. Indices range from (1,1) to (n,m). It returns an error if the requested element is outside of range.

Short alias for getElem.

O(1). Unsafe variant of getElem, without bounds checking.

Variant of getElem that returns Maybe instead of an error.

Variant of setElem that returns Maybe instead of an error.

O(1). Get a row of a matrix as a vector.

Varian of getRow that returns a maybe instead of an error

O(rows). Get a column of a matrix as a vector.

Varian of getColumn that returns a maybe instead of an error

O(min rows cols). Diagonal of a not necessarily square matrix.

O(rows*cols). Transform a Matrix to a Vector of size rows*cols. This is equivalent to get all the rows of the matrix using getRow and then append them, but far more efficient.

Replace the value of a cell in a matrix.

Unsafe variant of setElem, without bounds checking.

O(rows*cols). The transpose of a matrix. Example:

          ( 1 2 3 )   ( 1 4 7 )
          ( 4 5 6 )   ( 2 5 8 )
transpose ( 7 8 9 ) = ( 3 6 9 )

Set the size of a matrix to given parameters. Use a default element for undefined entries if the matrix has been extended.

Extend a matrix to a given size adding a default element. If the matrix already has the required size, nothing happens. The matrix is never reduced in size. Example:

                           ( 1 2 3 0 0 )
               ( 1 2 3 )   ( 4 5 6 0 0 )
               ( 4 5 6 )   ( 7 8 9 0 0 )
extendTo 0 4 5 ( 7 8 9 ) = ( 0 0 0 0 0 )

The definition of extendTo is based on setSize:

extendTo e n m a = setSize e (max n $ nrows a) (max m $ ncols a) a

O(rows*rows*rows*rows) = O(cols*cols*cols*cols). The inverse of a square matrix. Uses naive Gaussian elimination formula.

Converts a matrix to reduced row echelon form, thus solving a linear system of equations. This requires that (cols > rows) if cols < rows, then there are fewer variables than equations and the problem cannot be solved consistently. If rows = cols, then it is basically a homogenous system of equations, so it will be reduced to identity or an error depending on whether the marix is invertible (this case is allowed for robustness). This implementation is taken from rosettacode https://rosettacode.org/wiki/Reduced_row_echelon_form#Haskell

O(rows*cols). Map a function over a row. Example:

                         ( 1 2 3 )   ( 1 2 3 )
                         ( 4 5 6 )   ( 5 6 7 )
mapRow (\_ x -> x + 1) 2 ( 7 8 9 ) = ( 7 8 9 )

O(rows*cols). Map a function over a column. Example:

                         ( 1 2 3 )   ( 1 3 3 )
                         ( 4 5 6 )   ( 4 6 6 )
mapCol (\_ x -> x + 1) 2 ( 7 8 9 ) = ( 7 9 9 )

O(rows*cols). Map a function over elements. Example:

                           ( 1 2 3 )   ( 0 -1 -2 )
                           ( 4 5 6 )   ( 1  0 -1 )
mapPos (\(r,c) a -> r - c) ( 7 8 9 ) = ( 2  1  0 )

Perform an operation element-wise. The second matrix must have at least as many rows and columns as the first matrix. If it's bigger, the leftover items will be ignored. If it's smaller, it will cause a run-time error. You may want to use elementwiseUnsafe if you are definitely sure that a run-time error won't arise.

Unsafe version of elementwise, but faster.

Scale a matrix by a given factor. Example:

              ( 1 2 3 )   (  2  4  6 )
              ( 4 5 6 )   (  8 10 12 )
scaleMatrix 2 ( 7 8 9 ) = ( 14 16 18 )

Scale a row by a given factor. Example:

             ( 1 2 3 )   (  1  2  3 )
             ( 4 5 6 )   (  8 10 12 )
scaleRow 2 2 ( 7 8 9 ) = (  7  8  9 )

Add to one row a scalar multiple of another row. Example:

                  ( 1 2 3 )   (  1  2  3 )
                  ( 4 5 6 )   (  6  9 12 )
combineRows 2 2 1 ( 7 8 9 ) = (  7  8  9 )

Switch two rows of a matrix. Example:

               ( 1 2 3 )   ( 4 5 6 )
               ( 4 5 6 )   ( 1 2 3 )
switchRows 1 2 ( 7 8 9 ) = ( 7 8 9 )

Switch two coumns of a matrix. Example:

               ( 1 2 3 )   ( 2 1 3 )
               ( 4 5 6 )   ( 5 4 6 )
switchCols 1 2 ( 7 8 9 ) = ( 8 7 9 )

Matrix LU decomposition with partial pivoting. The result for a matrix M is given in the format (U,L,P,d) where:

• U is an upper triangular matrix.

• L is an unit lower triangular matrix.

• P is a permutation matrix.

• d is the determinant of P.

• PM = LU.

These properties are only guaranteed when the input matrix is invertible. An additional property matches thanks to the strategy followed for pivoting:

• L_(i,j) <= 1, for all i,j.

This follows from the maximal property of the selected pivots, which also leads to a better numerical stability of the algorithm.

Example:

         ( 1 2 0 )     ( 2 0  2 )   (   1 0 0 )   ( 0 0 1 )
         ( 0 2 1 )     ( 0 2 -1 )   ( 1/2 1 0 )   ( 1 0 0 )
luDecomp ( 2 0 2 ) = ( ( 0 0  2 ) , (   0 1 1 ) , ( 0 1 0 ) , 1 )

Nothing is returned if no LU decomposition exists.

Unsafe version of luDecomp. It fails when the input matrix is singular.

Matrix LU decomposition with complete pivoting. The result for a matrix M is given in the format (U,L,P,Q,d,e) where:

• U is an upper triangular matrix.

• L is an unit lower triangular matrix.

• P,Q are permutation matrices.

• d,e are the determinants of P and Q respectively.

• PMQ = LU.

These properties are only guaranteed when the input matrix is invertible. An additional property matches thanks to the strategy followed for pivoting:

• L_(i,j) <= 1, for all i,j.

This follows from the maximal property of the selected pivots, which also leads to a better numerical stability of the algorithm.

Example:

          ( 1 0 )     ( 2 1 )   (   1    0 0 )   ( 0 0 1 )
          ( 0 2 )     ( 0 2 )   (   0    1 0 )   ( 0 1 0 )   ( 1 0 )
luDecomp' ( 2 1 ) = ( ( 0 0 ) , ( 1/2 -1/4 1 ) , ( 1 0 0 ) , ( 0 1 ) , -1 , 1 )

Nothing is returned if no LU decomposition exists.

Unsafe version of luDecomp'. It fails when the input matrix is singular.

Simple Cholesky decomposition of a symmetric, positive definite matrix. The result for a matrix M is a lower triangular matrix L such that:

• M = LL^T.

Example:

           (  2 -1  0 )   (  1.41  0     0    )
           ( -1  2 -1 )   ( -0.70  1.22  0    )
cholDecomp (  0 -1  2 ) = (  0.00 -0.81  1.15 )

Sum of the elements in the diagonal. See also getDiag. Example:

      ( 1 2 3 )
      ( 4 5 6 )
trace ( 7 8 9 ) = 15

Product of the elements in the diagonal. See also getDiag. Example:

         ( 1 2 3 )
         ( 4 5 6 )
diagProd ( 7 8 9 ) = 45