Data.Sparse.SpMatrix

Sparse Matrix

data SpMatrix a

Constructors

SM

Fields

• smDim :: !(Rows, Cols)
• smData :: !(IntM (IntM a))

Instances

Functor SpMatrix

Methods

fmap :: (a -> b) -> SpMatrix a -> SpMatrix b

(<$) :: a -> SpMatrix b -> SpMatrix a

Foldable SpMatrix

Methods

fold :: Monoid m => SpMatrix m -> m

foldMap :: Monoid m => (a -> m) -> SpMatrix a -> m

foldr :: (a -> b -> b) -> b -> SpMatrix a -> b

foldr' :: (a -> b -> b) -> b -> SpMatrix a -> b

foldl :: (b -> a -> b) -> b -> SpMatrix a -> b

foldl' :: (b -> a -> b) -> b -> SpMatrix a -> b

foldr1 :: (a -> a -> a) -> SpMatrix a -> a

foldl1 :: (a -> a -> a) -> SpMatrix a -> a

toList :: SpMatrix a -> [a]

null :: SpMatrix a -> Bool

length :: SpMatrix a -> Int

elem :: Eq a => a -> SpMatrix a -> Bool

maximum :: Ord a => SpMatrix a -> a

minimum :: Ord a => SpMatrix a -> a

sum :: Num a => SpMatrix a -> a

product :: Num a => SpMatrix a -> a

Set SpMatrix

Methods

liftU2 :: (a -> a -> a) -> SpMatrix a -> SpMatrix a -> SpMatrix a

liftI2 :: (a -> a -> b) -> SpMatrix a -> SpMatrix a -> SpMatrix b

Eq a => Eq (SpMatrix a)

Methods

(==) :: SpMatrix a -> SpMatrix a -> Bool

(/=) :: SpMatrix a -> SpMatrix a -> Bool

Show a => Show (SpMatrix a)

Methods

showsPrec :: Int -> SpMatrix a -> ShowS

show :: SpMatrix a -> String

showList :: [SpMatrix a] -> ShowS

Num a => SpContainer (SpMatrix a)

SpMatrixes are sparse containers too, i.e. any specific component may be missing (so it is assumed to be 0)

Associated Types

type ScIx (SpMatrix a) :: *

type ScElem (SpMatrix a) :: *

Methods

scInsert :: ScIx (SpMatrix a) -> ScElem (SpMatrix a) -> SpMatrix a -> SpMatrix a

scLookup :: SpMatrix a -> ScIx (SpMatrix a) -> Maybe (ScElem (SpMatrix a))

scToList :: SpMatrix a -> [(ScIx (SpMatrix a), ScElem (SpMatrix a))]

(@@) :: SpMatrix a -> ScIx (SpMatrix a) -> ScElem (SpMatrix a)

Sparse (SpMatrix a)

Methods

spy :: Fractional b => SpMatrix a -> b

HasData (SpMatrix a)

Associated Types

type HDData (SpMatrix a) :: *

Methods

nnz :: SpMatrix a -> Int

dat :: SpMatrix a -> HDData (SpMatrix a)

FiniteDim (SpMatrix a)

SpMatrixes are maps between finite-dimensional spaces

Associated Types

type FDSize (SpMatrix a) :: *

Methods

dim :: SpMatrix a -> FDSize (SpMatrix a)

MatrixRing (SpMatrix Double)

Associated Types

type MatrixNorm (SpMatrix Double) :: *

Methods

(##) :: SpMatrix Double -> SpMatrix Double -> SpMatrix Double

(##^) :: SpMatrix Double -> SpMatrix Double -> SpMatrix Double

(#^#) :: SpMatrix Double -> SpMatrix Double -> SpMatrix Double

transpose :: SpMatrix Double -> SpMatrix Double

normFrobenius :: SpMatrix Double -> MatrixNorm (SpMatrix Double)

MatrixRing (SpMatrix (Complex Double))

Associated Types

type MatrixNorm (SpMatrix (Complex Double)) :: *

Methods

(##) :: SpMatrix (Complex Double) -> SpMatrix (Complex Double) -> SpMatrix (Complex Double)

(##^) :: SpMatrix (Complex Double) -> SpMatrix (Complex Double) -> SpMatrix (Complex Double)

(#^#) :: SpMatrix (Complex Double) -> SpMatrix (Complex Double) -> SpMatrix (Complex Double)

transpose :: SpMatrix (Complex Double) -> SpMatrix (Complex Double)

normFrobenius :: SpMatrix (Complex Double) -> MatrixNorm (SpMatrix (Complex Double))

Num a => AdditiveGroup (SpMatrix a)

SpMatrixes form an additive group, in that they can have an invertible associtative operation (matrix sum)

Methods

zeroV :: SpMatrix a

(^+^) :: SpMatrix a -> SpMatrix a -> SpMatrix a

negateV :: SpMatrix a -> SpMatrix a

(^-^) :: SpMatrix a -> SpMatrix a -> SpMatrix a

type ScIx (SpMatrix a)

type ScIx (SpMatrix a) = (Rows, Cols)

type ScElem (SpMatrix a)

type ScElem (SpMatrix a) = a

type HDData (SpMatrix a)

type HDData (SpMatrix a)

type FDSize (SpMatrix a)

type FDSize (SpMatrix a) = (Rows, Cols)

type MatrixNorm (SpMatrix Double)

type MatrixNorm (SpMatrix Double) = Double

type MatrixNorm (SpMatrix (Complex Double))

type MatrixNorm (SpMatrix (Complex Double)) = Double

sizeStrSM :: SpMatrix a -> String

Creation

zeroSM :: Rows -> Cols -> SpMatrix a

`zeroSM m n` : Empty SpMatrix of size (m, n)

Diagonal matrix

mkDiagonal :: Int -> [a] -> SpMatrix a

`mkDiagonal n ll` : create a diagonal matrix of size n from a list ll of elements

Identity matrix

eye :: Num a => Int -> SpMatrix a

`eye n` : identity matrix of rank n

Permutation matrix

permutationSM :: Num a => Int -> [IxRow] -> SpMatrix a

Permutation matrix from a (possibly incomplete) list of row swaps starting from row 0 e.g. `permutationSM 5 [1,3]` first swaps rows (0, 1) and then rows (1, 3) :

>>> prd (permutationSM 5 [1,3] :: SpMatrix Double)

( 5 rows, 5 columns ) , 5 NZ ( density 20.000 % )

_      , 1.00   , _      , _      , _      
_      , _      , _      , 1.00   , _      
_      , _      , 1.00   , _      , _      
1.00   , _      , _      , _      , _      
_      , _      , _      , _      , 1.00

permutPairsSM :: Num a => Int -> [(IxRow, IxRow)] -> SpMatrix a

Permutation matrix from a (possibly incomplete) list of row pair swaps e.g. `permutPairs 5 [(2,4)]` swaps rows 2 and 4 :

>>> prd (permutPairsSM 5 [(2,4)] :: SpMatrix Double)

( 5 rows, 5 columns ) , 5 NZ ( density 20.000 % )

1.00   , _      , _      , _      , _      
_      , 1.00   , _      , _      , _      
_      , _      , _      , _      , 1.00   
_      , _      , _      , 1.00   , _      
_      , _      , 1.00   , _      , _

Super- or sub- diagonal matrix

mkSubDiagonal :: Int -> Int -> [a] -> SpMatrix a

`mkSubDiagonal n o xx` creates a square SpMatrix of size n with xx on the oth subdiagonal

Element insertion

insertSpMatrix :: IxRow -> IxCol -> a -> SpMatrix a -> SpMatrix a

Insert an element in a preexisting Spmatrix at the specified indices

fromList

fromListSM' :: Foldable t => t (IxRow, IxCol, a) -> SpMatrix a -> SpMatrix a

Add to existing SpMatrix using data from list (row, col, value)

fromListSM :: Foldable t => (Int, Int) -> t (IxRow, IxCol, a) -> SpMatrix a

Create new SpMatrix using data from a Foldable (e.g. a list) in (row, col, value) form

mkSpMR :: Foldable t => (Int, Int) -> t (IxRow, IxCol, Double) -> SpMatrix Double

mkSpMC :: Foldable t => (Int, Int) -> t (IxRow, IxCol, Complex Double) -> SpMatrix (Complex Double)

fromListDenseSM :: Int -> [a] -> SpMatrix a

Create new SpMatrix assuming contiguous, 0-based indexing of elements

toList

toListSM :: SpMatrix t -> [(IxRow, IxCol, t)]

Populate list with SpMatrix contents

toDenseListSM :: Num t => SpMatrix t -> [(IxRow, IxCol, t)]

Populate list with SpMatrix contents and populate missing entries with 0

Lookup

lookupSM :: SpMatrix a -> IxRow -> IxCol -> Maybe a

lookupWD_SM :: Num a => SpMatrix a -> (IxRow, IxCol) -> a

Looks up an element in the matrix with a default (if the element is not found, zero is returned)

(@@!) :: Num a => SpMatrix a -> (IxRow, IxCol) -> a

Zero-default lookup, infix form (no bound checking)

Looks up an element in the matrix with a default (if the element is not found, zero is returned)

Sub-matrices

filterSM :: (Key -> Key -> a -> Bool) -> SpMatrix a -> SpMatrix a

Indexed filtering function

extractDiag :: SpMatrix a -> SpMatrix a

Diagonal, subdiagonal, superdiagonal partitions of a SpMatrix (useful for writing preconditioners)

extractSuperDiag :: SpMatrix a -> SpMatrix a

Diagonal, subdiagonal, superdiagonal partitions of a SpMatrix (useful for writing preconditioners)

extractSubDiag :: SpMatrix a -> SpMatrix a

Diagonal, subdiagonal, superdiagonal partitions of a SpMatrix (useful for writing preconditioners)

extractSubmatrixSM :: (Key -> Key) -> (Key -> Key) -> SpMatrix a -> (IxRow, IxRow) -> (IxCol, IxCol) -> SpMatrix a

Extract a submatrix given the specified index bounds, rebalancing keys with the two supplied functions

extractSubmatrixRebalanceKeys :: SpMatrix a -> (IxRow, IxRow) -> (IxCol, IxCol) -> SpMatrix a

Extract a submatrix given the specified index bounds NB : subtracts (i1, j1) from the indices

extractSubmatrix :: SpMatrix a -> (IxRow, IxRow) -> (IxCol, IxCol) -> SpMatrix a

Extract a submatrix given the specified index bounds NB : submatrix indices are _preserved_

takeRows :: IxRow -> SpMatrix a -> SpMatrix a

takeCols :: IxCol -> SpMatrix a -> SpMatrix a

Extract i'th row

Extract j'th column

extractColSM :: SpMatrix a -> IxCol -> SpMatrix a

Extract whole column

extractSubColSM :: SpMatrix a -> IxCol -> (IxRow, IxRow) -> SpMatrix a

Extract column within a row range

extractSubColSM_RK :: SpMatrix a -> IxCol -> (IxRow, IxRow) -> SpMatrix a

Extract column within a row range, rebalance keys

Predicates

isValidIxSM :: SpMatrix a -> (Int, Int) -> Bool

Are the supplied indices within matrix bounds?

isSquareSM :: SpMatrix a -> Bool

Is the matrix square?

isDiagonalSM :: SpMatrix a -> Bool

Is the matrix diagonal?

isLowerTriSM :: Eq a => SpMatrix a -> Bool

Is the matrix lower/upper triangular?

isUpperTriSM :: Eq a => SpMatrix a -> Bool

Is the matrix lower/upper triangular?

isOrthogonalSM :: (Eq a, Epsilon a, MatrixRing (SpMatrix a)) => SpMatrix a -> Bool

Is the matrix orthogonal? i.e. Q^t ## Q == I

Matrix data and metadata

immSM :: SpMatrix a -> IntM (IntM a)

Data in internal representation (do not export) immSM :: SpMatrix t -> IM.IntMap (IM.IntMap t)

dimSM :: SpMatrix t -> (Rows, Cols)

(Number of rows, Number of columns)

nelSM :: SpMatrix t -> Int

Number of rows times number of columns

nrows :: SpMatrix a -> Rows

Number of rows

ncols :: SpMatrix a -> Cols

Number of columns

data SMInfo

Constructors

SMInfo

Fields

• smNz :: Int
• smSpy :: Double

Instances

Eq SMInfo

Methods

(==) :: SMInfo -> SMInfo -> Bool

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

Show SMInfo

Methods

showsPrec :: Int -> SMInfo -> ShowS

show :: SMInfo -> String

showList :: [SMInfo] -> ShowS

infoSM :: SpMatrix a -> SMInfo

nzSM :: SpMatrix a -> Int

spySM :: Fractional b => SpMatrix a -> b

Non-zero elements in a row

nzRow :: SpMatrix a -> Key -> Int

Bandwidth bounds (min, max)

bwMinSM :: SpMatrix a -> Int

bwMaxSM :: SpMatrix a -> Int

bwBoundsSM :: SpMatrix a -> (Int, Int)

Matrix stacking

vertStackSM :: SpMatrix a -> SpMatrix a -> SpMatrix a

Vertical stacking of matrix blocks

(-=-) :: SpMatrix a -> SpMatrix a -> SpMatrix a

Vertical stacking of matrix blocks

horizStackSM :: SpMatrix a -> SpMatrix a -> SpMatrix a

Horizontal stacking of matrix blocks

(-||-) :: SpMatrix a -> SpMatrix a -> SpMatrix a

Horizontal stacking of matrix blocks

fromBlocksDiag :: [SpMatrix a] -> SpMatrix a

Assemble a block-diagonal square matrix from a list of square matrices, arranging these along the main diagonal

Misc. SpMatrix operations

ifilterSM :: (Key -> Key -> a -> Bool) -> SpMatrix a -> SpMatrix a

Indexed filter over SpMatrix

foldlSM :: (a -> b -> b) -> b -> SpMatrix a -> b

Left fold over SpMatrix

ifoldlSM :: (Key -> Key -> a -> b -> b) -> b -> SpMatrix a -> b

Indexed left fold over SpMatrix

countSubdiagonalNZSM :: SpMatrix a -> Int

Count sub-diagonal nonzeros

subdiagIndicesSM :: SpMatrix a -> [(IxRow, IxCol)]

Filter the index subset that lies below the diagonal (used in the QR decomposition, for example)

Sparsify : remove almost-0 elements (|x| < eps)

sparsifyIM2 :: Epsilon a => IntM (IntM a) -> IntM (IntM a)

sparsifySM :: Epsilon a => SpMatrix a -> SpMatrix a

Sparsify an SpMatrix

Value rounding

roundZeroOneSM :: Epsilon a => SpMatrix a -> SpMatrix a

Round almost-0 and almost-1 to 0 and 1 respectively

modifyKeysSM' :: (IxRow -> a) -> (IxCol -> b) -> SpMatrix c -> [(a, b, c)]

Modify (row, column) keys, leaving data intact. Be careful when using this! modifyKeysSM' :: (IxRow -> IxRow) -> (IxCol -> IxCol) -> SpMatrix a -> SpMatrix a

modifyKeysSM :: (IxRow -> IxRow) -> (IxCol -> IxCol) -> SpMatrix a -> SpMatrix a

Primitive algebra operations

Matrix row swap

swapRows :: IxRow -> IxRow -> SpMatrix a -> SpMatrix a

Swap two rows of a SpMatrix (bounds not checked)

swapRowsSafe :: IxRow -> IxRow -> SpMatrix a -> SpMatrix a

Swap two rows of a SpMatrix (bounds checked)

Matrix transpose

transposeSM :: SpMatrix a -> SpMatrix a

transposeSM : Matrix transpose

hermitianConj :: Num a => SpMatrix (Complex a) -> SpMatrix (Complex a)

Hermitian conjugate

Multiply matrix by a scalar

matScale :: Num a => a -> SpMatrix a -> SpMatrix a

Trace

trace :: Num b => SpMatrix b -> b

Matrix trace

Frobenius norm

normFrobeniusSM :: (MatrixRing (SpMatrix a), Floating a) => SpMatrix a -> a

normFrobeniusSMC :: (MatrixRing (SpMatrix (Complex a)), RealFloat a) => SpMatrix (Complex a) -> a

Matrix-matrix product

data MatProd_

Internal implementation

Constructors

AB

ABt

Instances

Eq MatProd_

Methods

(==) :: MatProd_ -> MatProd_ -> Bool

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

Show MatProd_

Methods

showsPrec :: Int -> MatProd_ -> ShowS

show :: MatProd_ -> String

showList :: [MatProd_] -> ShowS

matMat_ :: Num a => MatProd_ -> SpMatrix a -> SpMatrix a -> SpMatrix a

matMatUnsafeWith :: Num a1 => (IntM (IntM a2) -> IntM (IntM a1)) -> SpMatrix a1 -> SpMatrix a2 -> SpMatrix a1

Matrix product without dimension checks

Matrix-matrix product, sparsified

matMatSparsified :: (MatrixRing (SpMatrix a), Epsilon a) => SpMatrix a -> SpMatrix a -> SpMatrix a

After multiplying the two matrices, all elements x for which `| x | <= eps` are removed.

(#~#) :: (MatrixRing (SpMatrix a), Epsilon a) => SpMatrix a -> SpMatrix a -> SpMatrix a

After multiplying the two matrices, all elements x for which `| x | <= eps` are removed.

Sparsified matrix products of two matrices

(#~#^) :: (MatrixRing (SpMatrix a), Epsilon a) => SpMatrix a -> SpMatrix a -> SpMatrix a

Sparsifying A^T B

(#~^#) :: (MatrixRing (SpMatrix a), Epsilon a) => SpMatrix a -> SpMatrix a -> SpMatrix a

Sparsifying A B^T

Partial inner product

contractSub :: Elt a => SpMatrix a -> SpMatrix a -> IxRow -> IxCol -> Int -> a

Contract row i of A with column j of B up to an index n, i.e. summing over repeated indices: Aij Bjk , for j in [0 .. n]