Math.Linear.Sparse

Additive ring

class Functor f => Additive f where

Minimal complete definition

zero, (^+^)

Methods

zero :: Num a => f a

Ring zero element

(^+^) :: Num a => f a -> f a -> f a

Ring +

Instances

Additive IntMap

Methods

zero :: Num a => IntMap a

(^+^) :: Num a => IntMap a -> IntMap a -> IntMap a

Additive SpMatrix

Methods

zero :: Num a => SpMatrix a

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

Additive SpVector

Methods

zero :: Num a => SpVector a

(^+^) :: Num a => SpVector a -> SpVector a -> SpVector a

negated :: (Num a, Functor f) => f a -> f a

negate the values in a functor

(^-^) :: (Additive f, Num a) => f a -> f a -> f a

subtract two Additive objects

Vector space

class Additive f => VectorSpace f where

Minimal complete definition

(.*)

Methods

(.*) :: Num a => a -> f a -> f a

multiplication by a scalar

Instances

VectorSpace IntMap

Methods

(.*) :: Num a => a -> IntMap a -> IntMap a

VectorSpace SpVector

Methods

(.*) :: Num a => a -> SpVector a -> SpVector a

lerp :: (VectorSpace f, Num a) => a -> f a -> f a -> f a

linear interpolation

Hilbert space (inner product)

class VectorSpace f => Hilbert f where

Minimal complete definition

dot

Methods

dot :: Num a => f a -> f a -> a

inner product

Instances

Hilbert IntMap

Methods

dot :: Num a => IntMap a -> IntMap a -> a

Hilbert SpVector

Methods

dot :: Num a => SpVector a -> SpVector a -> a

Normed vector space

class Hilbert f => Normed f where

Minimal complete definition

norm

Methods

norm :: (Floating a, Eq a) => a -> f a -> a

Instances

Normed IntMap

Methods

norm :: (Floating a, Eq a) => a -> IntMap a -> a

Normed SpVector

Methods

norm :: (Floating a, Eq a) => a -> SpVector a -> a

Norms and related results

squared 2-norm

normSq :: (Hilbert f, Num a) => f a -> a

L1 norm

norm1 :: (Foldable t, Num a, Functor t) => t a -> a

Euclidean norm

norm2 :: (Hilbert f, Floating a) => f a -> a

Lp norm (p > 0)

normP :: (Foldable t, Functor t, Floating a) => a -> t a -> a

infinity-norm

normInfty :: (Foldable t, Ord a) => t a -> a

normalize w.r.t. p-norm (p finite)

normalize :: (Normed f, Floating a, Eq a) => a -> f a -> f a

Lp inner product (p > 0)

dotLp :: (Set t, Foldable t, Floating a) => a -> t a -> t a -> a

reciprocal

reciprocal :: (Functor f, Fractional b) => f b -> f b

scale

scale :: (Num b, Functor f) => b -> f b -> f b

FiniteDim : finite-dimensional objects

class Additive f => FiniteDim f where

Minimal complete definition

dim

Associated Types

type FDSize f :: *

Methods

dim :: f a -> FDSize f

Instances

FiniteDim SpMatrix

Associated Types

type FDSize (SpMatrix :: * -> *) :: *

Methods

dim :: SpMatrix a -> FDSize SpMatrix

FiniteDim SpVector

Associated Types

type FDSize (SpVector :: * -> *) :: *

Methods

dim :: SpVector a -> FDSize SpVector

withDim :: (FiniteDim f, Show e) => f a -> (FDSize f -> f a -> Bool) -> (f a -> c) -> String -> (f a -> e) -> c

unary dimension-checking bracket

withDim2 :: (FiniteDim f, FiniteDim g, Show e) => f a -> g b -> (FDSize f -> FDSize g -> f a -> g b -> Bool) -> (f a -> g b -> c) -> String -> (f a -> g b -> e) -> c

binary dimension-checking bracket

HasData : accessing inner data (do not export)

class Additive f => HasData f a where

Minimal complete definition

dat

Associated Types

type HDData f a :: *

Methods

dat :: f a -> HDData f a

Instances

HasData SpMatrix a

Associated Types

type HDData (SpMatrix :: * -> *) a :: *

Methods

dat :: SpMatrix a -> HDData SpMatrix a

HasData SpVector a

Associated Types

type HDData (SpVector :: * -> *) a :: *

Methods

dat :: SpVector a -> HDData SpVector a

Sparse : sparse datastructures

class (FiniteDim f, HasData f a) => Sparse f a where

Minimal complete definition

spy

Methods

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

Instances

Sparse SpMatrix a

Methods

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

Sparse SpVector a

Methods

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

Set : things that behave as sets (e.g. of which we can take the union and the intersection)

class Functor f => Set f where

Minimal complete definition

liftU2, liftI2

Methods

liftU2 :: (a -> a -> a) -> f a -> f a -> f a

union binary lift

liftI2 :: (a -> b -> c) -> f a -> f b -> f c

intersection binary lift

Instances

Set IntMap

Methods

liftU2 :: (a -> a -> a) -> IntMap a -> IntMap a -> IntMap a

liftI2 :: (a -> b -> c) -> IntMap a -> IntMap b -> IntMap c

Set SpMatrix

Methods

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

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

Set SpVector

Methods

liftU2 :: (a -> a -> a) -> SpVector a -> SpVector a -> SpVector a

liftI2 :: (a -> b -> c) -> SpVector a -> SpVector b -> SpVector c

IntMap implementation

Sparse Vector

data SpVector a

Constructors

SV

Fields

• svDim :: Int
• svData :: IntMap a

Instances

Functor SpVector

Methods

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

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

Foldable SpVector

Methods

fold :: Monoid m => SpVector m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> SpVector a -> a

foldl1 :: (a -> a -> a) -> SpVector a -> a

toList :: SpVector a -> [a]

null :: SpVector a -> Bool

length :: SpVector a -> Int

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

maximum :: Ord a => SpVector a -> a

minimum :: Ord a => SpVector a -> a

sum :: Num a => SpVector a -> a

product :: Num a => SpVector a -> a

Set SpVector

Methods

liftU2 :: (a -> a -> a) -> SpVector a -> SpVector a -> SpVector a

liftI2 :: (a -> b -> c) -> SpVector a -> SpVector b -> SpVector c

FiniteDim SpVector

Associated Types

type FDSize (SpVector :: * -> *) :: *

Methods

dim :: SpVector a -> FDSize SpVector

Normed SpVector

Methods

norm :: (Floating a, Eq a) => a -> SpVector a -> a

Hilbert SpVector

Methods

dot :: Num a => SpVector a -> SpVector a -> a

VectorSpace SpVector

Methods

(.*) :: Num a => a -> SpVector a -> SpVector a

Additive SpVector

Methods

zero :: Num a => SpVector a

(^+^) :: Num a => SpVector a -> SpVector a -> SpVector a

Sparse SpVector a

Methods

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

HasData SpVector a

Associated Types

type HDData (SpVector :: * -> *) a :: *

Methods

dat :: SpVector a -> HDData SpVector a

Eq a => Eq (SpVector a)

Methods

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

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

Show a => Show (SpVector a)

Methods

showsPrec :: Int -> SpVector a -> ShowS

show :: SpVector a -> String

showList :: [SpVector a] -> ShowS

(Show a, Num a) => PrintDense (SpVector a)

Methods

prd :: SpVector a -> IO ()

type FDSize SpVector

type FDSize SpVector = Int

type HDData SpVector a

type HDData SpVector a = IntMap a

spySV :: Fractional b => SpVector a -> b

SpVector sparsity

instances for SpVector

zeroSV :: Int -> SpVector a

empty sparse vector (size n, no entries)

singletonSV :: a -> SpVector a

Create new sparse vector

mkSpVector :: (Num a, Eq a) => Int -> IntMap a -> SpVector a

create a sparse vector from an association list while discarding all zero entries

mkSpVectorD :: (Num a, Eq a) => Int -> [a] -> SpVector a

", from logically dense array (consecutive indices)

mkSpVector1 :: Int -> IntMap a -> SpVector a

fromListDenseSV :: Int -> [a] -> SpVector a

Create new sparse vector, assumin 0-based, contiguous indexing

onesSV :: Num a => Int -> SpVector a

DENSE vector of `1`s

zerosSV :: Num a => Int -> SpVector a

DENSE vector of `0`s

insertSpVector :: Int -> a -> SpVector a -> SpVector a

insert element x at index i in a preexisting SpVector

fromListSV :: Int -> [(Int, a)] -> SpVector a

toListSV :: SpVector a -> [(Key, a)]

toList

toDenseListSV :: Num b => SpVector b -> [b]

To dense list (default = 0)

lookupDenseSV :: Num a => Key -> SpVector a -> a

lookup

findWithDefault0IM :: Num a => Key -> IntMap a -> a

tailSV :: SpVector a -> SpVector a

SV manipulation

Tail elements

headSV :: Num a => SpVector a -> a

Head element

concatSV :: SpVector a -> SpVector a -> SpVector a

concatenate SpVector

svToSM :: SpVector a -> SpMatrix a

promote a SV to SM

Outer vector product

outerProdSV :: Num a => SpVector a -> SpVector a -> SpMatrix a

(><) :: Num a => SpVector a -> SpVector a -> SpMatrix a

Sparse Matrix

data SpMatrix a

Constructors

SM

Fields

• smDim :: (Rows, Cols)
• smData :: IntMap (IntMap a)

Instances

Functor SpMatrix

Methods

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

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

Set SpMatrix

Methods

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

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

FiniteDim SpMatrix

Associated Types

type FDSize (SpMatrix :: * -> *) :: *

Methods

dim :: SpMatrix a -> FDSize SpMatrix

Additive SpMatrix

Methods

zero :: Num a => SpMatrix a

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

Sparse SpMatrix a

Methods

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

HasData SpMatrix a

Associated Types

type HDData (SpMatrix :: * -> *) a :: *

Methods

dat :: SpMatrix a -> HDData SpMatrix a

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

(Show a, Num a) => PrintDense (SpMatrix a)

Methods

prd :: SpMatrix a -> IO ()

type FDSize SpMatrix

type FDSize SpMatrix = (Rows, Cols)

type HDData SpMatrix a

type HDData SpMatrix a = IntMap (IntMap a)

Instances for SpMatrix

maxTup :: Ord t => (t, t) -> (t, t) -> (t, t)

TODO : use semilattice properties instead

minTup :: Ord t => (t, t) -> (t, t) -> (t, t)

TODO : use semilattice properties instead

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

empty matrix of size d

multiply matrix by a scalar

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

Frobenius norm (sqrt of trace of M^T M)

normFrobenius :: SpMatrix Double -> Double

MATRIX METADATA

type Rows = Int

type Cols = Int

type IxRow = Int

type IxCol = Int

predicates

validIxSM :: 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?

immSM :: SpMatrix t -> IntMap (IntMap t)

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

nelSM :: SpMatrix t -> Int

nrows :: SpMatrix a -> Int

nrows, ncols : size accessors

ncols :: SpMatrix a -> Int

nrows, ncols : size accessors

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

nzRowU :: SpMatrix a -> Key -> Int

nzRow :: SpMatrix a -> Key -> Int

bandwidth bounds (min, max)

bwMinSM :: SpMatrix a -> Int

bwMaxSM :: SpMatrix a -> Int

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

SPARSE MATRIX BUILDERS

zeroSM :: Int -> Int -> SpMatrix a

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

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 list (row, col, value)

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

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

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

to List

Populate missing entries with 0

Diagonal matrix

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

Identity matrix

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

ones :: Num a => Int -> [a]

Create Super- or sub- diagonal matrix

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

encode :: (Int, Int) -> (Rows, Cols) -> Int

decode :: (Int, Int) -> Int -> (Rows, Cols)

SUB-MATRICES

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

toSV :: SpMatrix a -> SpVector a

Demote (n x 1) or (1 x n) SpMatrix to SpVector

Extract jth column

extractColSM :: SpMatrix a -> Int -> SpMatrix a

extractCol :: SpMatrix a -> Int -> SpVector a

", and place into SpVector

Extract ith row

extractRowSM :: SpMatrix a -> Int -> SpMatrix a

extractRow :: SpMatrix a -> Int -> SpVector a

", and place into SpVector

MATRIX STACKING

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

Vertical stacking

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

Vertical stacking

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

Horizontal stacking

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

Horizontal stacking

MATRIX ELEMENT LOOKUP

lookupSM :: SpMatrix a -> Key -> Key -> Maybe a

lookupWD_SM :: Num a => SpMatrix a -> (Key, Key) -> a

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

(@@) :: Num a => SpMatrix a -> (Key, Key) -> a

Zero-default lookup, infix form

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

lookupWD_IM :: Num a => IntMap (IntMap a) -> (Key, Key) -> a

MISC SpMatrix OPERATIONS

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

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

countSubdiagonalNZSM :: SpMatrix a -> Int

mapping

folding

extractDiagonalDSM :: Num a => SpMatrix a -> SpVector a

filtering

extract with default 0

subdiagIndicesSM :: SpMatrix a -> [(Key, Key)]

sparsify : remove 0s (!!!)

sparsifyIM2 :: IntMap (IntMap Double) -> IntMap (IntMap Double)

sparsifySM :: SpMatrix Double -> SpMatrix Double

ROUNDING operations (!!!)

roundZeroOneSM :: SpMatrix Double -> SpMatrix Double

ALGEBRAIC PRIMITIVE OPERATIONS

Matrix transpose

transposeSM :: SpMatrix a -> SpMatrix a

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

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

A^T B

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

A B^T

matrix action on a vector

matVec :: Num a => SpMatrix a -> SpVector a -> SpVector a

matrix on vector

(#>) :: Num a => SpMatrix a -> SpVector a -> SpVector a

matrix on vector

vecMat :: Num a => SpVector a -> SpMatrix a -> SpVector a

vector on matrix (FIXME : transposes matrix: more costly than matVec, I think)

(<#) :: Num a => SpVector a -> SpMatrix a -> SpVector a

vector on matrix (FIXME : transposes matrix: more costly than matVec, I think)

Matrix-matrix product

matMatU :: Num a => SpMatrix a -> SpMatrix a -> SpMatrix a

matMat :: Num a => SpMatrix a -> SpMatrix a -> SpMatrix a

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

Matrix-matrix product, sparsified (prunes all elements x for which `abs x <= eps`)

matMatSparsified :: SpMatrix Double -> SpMatrix Double -> SpMatrix Double

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

Predicates

isOrthogonalSM :: SpMatrix Double -> Bool

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

Condition number

conditionNumberSM :: SpMatrix Double -> Double

uses the R matrix from the QR factorization

Householder transformation

hhMat :: Num a => a -> SpVector a -> SpMatrix a

hhRefl :: SpVector Double -> SpMatrix Double

a vector x uniquely defines an orthogonal plane; the Householder operator reflects any point v with respect to this plane: v' = (I - 2 x >< x) v

Givens rotation matrix

hypot :: Floating a => a -> a -> a

sign :: (Ord a, Num a) => a -> a

givensCoef :: (Ord a, Floating a) => a -> a -> (a, a, a)

Givens coefficients (using stable algorithm shown in Anderson, Edward (4 December 2000). "Discontinuous Plane Rotations and the Symmetric Eigenvalue Problem". LAPACK Working Note)

givens :: SpMatrix Double -> Int -> Int -> SpMatrix Double

Givens method, row version: choose other row index i' s.t. i' is : * below the diagonal * corresponding element is nonzero

QR.C1 ) To zero out entry A(i, j) we must find row k such that A(k, j) is non-zero but A has zeros in row k for all columns less than j.

firstNonZeroColumn :: IntMap a -> Key -> Bool

Is the kth the first nonzero column in the row?

candidateRows :: IntMap (IntMap a) -> Key -> Key -> Maybe [Key]

Returns a set of rows {k} that satisfy QR.C1

QR decomposition

qr :: SpMatrix Double -> (SpMatrix Double, SpMatrix Double)

Applies Givens rotation iteratively to zero out sub-diagonal elements

gmats :: SpMatrix Double -> [SpMatrix Double]

Givens matrices in order [G1, G2, .. , G_N ]

Eigenvalue algorithms

All eigenvalues using QR algorithm

eigsQR :: Int -> SpMatrix Double -> SpVector Double

One eigenvalue and corresponding eigenvector, using Rayleigh iteration

rayleighStep :: SpMatrix Double -> (SpVector Double, Double) -> (SpVector Double, Double)

Cubic-order convergence, but it requires a mildly educated guess on the initial eigenpair

eigRayleigh :: Int -> SpMatrix Double -> (SpVector Double, Double) -> (SpVector Double, Double)

Householder vector (G & VL Alg. 5.1.1, function house)

hhV :: SpVector Double -> (SpVector Double, Double)

SVD

LINEAR SOLVERS : solve A x = b

eps :: Double

numerical tolerance for e.g. solution convergence

residual :: Num a => SpMatrix a -> SpVector a -> SpVector a -> SpVector a

residual of candidate solution x0

converged :: SpMatrix Double -> SpVector Double -> SpVector Double -> Bool

CGS

cgsStep :: SpMatrix Double -> SpVector Double -> CGS -> CGS

one step of CGS

data CGS

Constructors

CGS

Fields

• _x :: SpVector Double
• _r :: SpVector Double
• _p :: SpVector Double
• _u :: SpVector Double

Instances

Eq CGS

Methods

(==) :: CGS -> CGS -> Bool

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

Show CGS

Methods

showsPrec :: Int -> CGS -> ShowS

show :: CGS -> String

showList :: [CGS] -> ShowS

cgs :: SpMatrix Double -> SpVector Double -> SpVector Double -> SpVector Double -> CGS

iterate solver until convergence or until max # of iterations is reached

BiCSSTAB

bicgstabStep :: SpMatrix Double -> SpVector Double -> BICGSTAB -> BICGSTAB

one step of BiCGSTAB

data BICGSTAB

Constructors

BICGSTAB

Fields

• _xBicgstab :: SpVector Double
• _rBicgstab :: SpVector Double
• _pBicgstab :: SpVector Double

Instances

Eq BICGSTAB

Methods

(==) :: BICGSTAB -> BICGSTAB -> Bool

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

Show BICGSTAB

Methods

showsPrec :: Int -> BICGSTAB -> ShowS

show :: BICGSTAB -> String

showList :: [BICGSTAB] -> ShowS

bicgstab :: SpMatrix Double -> SpVector Double -> SpVector Double -> SpVector Double -> BICGSTAB

iterate solver until convergence or until max # of iterations is reached

LINEAR SOLVERS INTERFACE

data LinSolveMethod

Constructors

CGS_

BICGSTAB_

Instances

Eq LinSolveMethod

Methods

(==) :: LinSolveMethod -> LinSolveMethod -> Bool

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

Show LinSolveMethod

Methods

showsPrec :: Int -> LinSolveMethod -> ShowS

show :: LinSolveMethod -> String

showList :: [LinSolveMethod] -> ShowS

linSolveM :: PrimMonad m => LinSolveMethod -> SpMatrix Double -> SpVector Double -> m (SpVector Double)

linear solve with _random_ starting vector

linSolve :: LinSolveMethod -> SpMatrix Double -> SpVector Double -> SpVector Double

linear solve with _deterministic_ starting vector (every component at 0.1)

(<\>) :: SpMatrix Double -> SpVector Double -> SpVector Double

PRETTY PRINTING

sizeStr :: SpMatrix a -> String

showNonZero :: (Show a, Num a, Eq a) => a -> String

toDenseRow :: Num a => SpMatrix a -> Key -> [a]

toDenseRowClip :: (Show a, Num a) => SpMatrix a -> Key -> Int -> String

newline :: IO ()

printDenseSM :: (Show t, Num t) => SpMatrix t -> IO ()

toDenseListClip :: (Show a, Num a) => SpVector a -> Int -> String

printDenseSV :: (Show t, Num t) => SpVector t -> IO ()

Pretty printer typeclass

class PrintDense a where

Minimal complete definition

prd

Methods

prd :: a -> IO ()

Instances

(Show a, Num a) => PrintDense (SpMatrix a)

Methods

prd :: SpMatrix a -> IO ()

(Show a, Num a) => PrintDense (SpVector a)

Methods

prd :: SpVector a -> IO ()

almostZero :: Double -> Bool

rounding to 0 or 1 within some predefined numerical precision

almostOne :: Double -> Bool

rounding to 0 or 1 within some predefined numerical precision

withDefault :: (t -> Bool) -> t -> t -> t

roundZero :: Double -> Double

roundOne :: Double -> Double

with2Defaults :: (t -> Bool) -> (t -> Bool) -> t -> t -> t -> t

roundZeroOne :: Double -> Double

modifyUntil :: MonadState s m => (s -> Bool) -> (s -> s) -> m s

transform state until a condition is met

loopUntilAcc :: Int -> ([t] -> Bool) -> (t -> t) -> t -> t

modifyInspectN :: MonadState s m => Int -> ([s] -> Bool) -> (s -> s) -> m s

keep state x in a moving window of length 2 to assess convergence, stop when either a condition on that list is satisfied or when max # of iterations is reached

meanl :: (Foldable t, Fractional a) => t a -> a

norm2l :: (Foldable t, Functor t, Floating a) => t a -> a

diffSqL :: Floating a => [a] -> a

untilConverged :: MonadState a m => (a -> SpVector Double) -> (a -> a) -> m a

normDiffConverged :: (Foldable t, Functor t) => (a -> SpVector Double) -> t a -> Bool

runAppendN :: ([t] -> Bool) -> (t -> t) -> Int -> t -> [t]

runAppendN' :: (t -> t) -> Int -> t -> [t]

randMat :: PrimMonad m => Int -> m (SpMatrix Double)

random matrices and vectors

randVec :: PrimMonad m => Int -> m (SpVector Double)

randSpMat :: Int -> Int -> IO (SpMatrix Double)

randSpVec :: Int -> Int -> IO (SpVector Double)

denseIxArray :: [b] -> [(Int, b)]

misc utils

integer-indexed ziplist

denseIxArray2 :: Int -> [c] -> [(Int, Int, c)]

foldrMap :: (Foldable t, Functor t) => (a -> b) -> (b -> c -> c) -> c -> t a -> c

foldlStrict :: (a -> b -> a) -> a -> [b] -> a

ifoldr :: Num i => (a -> b -> b) -> b -> (i -> c -> d -> a) -> c -> [d] -> b

type LB = Int

type UB = Int

inBounds :: LB -> UB -> Int -> Bool

inBounds2 :: (LB, UB) -> (Int, Int) -> Bool

inBounds0 :: UB -> Int -> Bool

inBounds02 :: (UB, UB) -> (Int, Int) -> Bool