Math.Linear.Sparse

Documentation

class Functor f => Additive f where

=== CLASSES and common operations

Additive ring

Minimal complete definition

zero, (^+^), (^-^)

Methods

zero :: Num a => f a

zero element

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

componentwise operations

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

Instances

Additive IntMap

IntMap implementation

Methods

zero :: Num a => IntMap a

(^+^) :: Num a => IntMap a -> IntMap 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

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

Additive SpVector

Methods

zero :: Num a => SpVector a

(^+^) :: Num a => SpVector a -> SpVector 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

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

class Additive f => VectorSpace f where

Vector space

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

class VectorSpace f => Hilbert f where

Hilbert space (inner product)

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

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

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

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

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

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

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

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

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

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

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

class Additive f => FiniteDim f where

FiniteDim : finite-dimensional objects

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

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

class Additive f => HasData f a where

HasData : accessing inner data (do not export)

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

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

Sparse : sparse datastructures

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

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

data SpVector a

=================================================

Sparse Vector

Constructors

SV

Fields

• svDim :: Int
• svData :: IntMap a

Instances

Functor SpVector

instances for 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

(^-^) :: 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

dimSV :: SpVector a -> Int

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

imSV :: SpVector a -> IntMap a

zeroSV :: Int -> SpVector a

empty sparse vector (size n, no entries)

singletonSV :: a -> SpVector a

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

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

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

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

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

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

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

lookup

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

tailSV :: SpVector a -> SpVector a

SV manipulation

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

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

concatenate SpVector

svToSM :: SpVector a -> SpMatrix a

promote a SV to SM

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

outer vector product

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

outer vector product

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

(^-^) :: 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)

instances for SpMatrix

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)

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

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

normFrobenius :: SpMatrix Double -> Double

type Rows = Int

=== MATRIX METADATA

type Cols = Int

type IxRow = Int

type IxCol = Int

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

isSquareSM :: SpMatrix a -> Bool

isDiagonalSM :: SpMatrix a -> Bool

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

nzRowU :: SpMatrix a -> Key -> Int

nzRow :: SpMatrix a -> Key -> Int

bwMinSM :: SpMatrix a -> Int

bandwidth bounds (min, max)

bwMaxSM :: SpMatrix a -> Int

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

zeroSM :: Int -> Int -> SpMatrix a

=== SPARSE MATRIX BUILDERS

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

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

from list (row, col, value)

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

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

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

to List

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

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

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

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

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

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

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

=== SUB-MATRICES

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

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

toSV :: SpMatrix a -> SpVector a

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

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

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

=== MATRIX STACKING

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

=== MATRIX STACKING

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

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

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

=== LOOKUP

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

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

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

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

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

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

=== MISC SpMatrix OPERATIONS

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

countSubdiagonalNZSM :: SpMatrix a -> Int

mapping

folding

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

filtering

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

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

sparsify : remove 0s (!!!)

sparsifySM :: SpMatrix Double -> SpMatrix Double

roundZeroOneSM :: SpMatrix Double -> SpMatrix Double

ROUNDING operations (!!!)

transposeSM :: SpMatrix a -> SpMatrix a

=== ALGEBRAIC PRIMITIVE OPERATIONS

transpose

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

=== ALGEBRAIC PRIMITIVE OPERATIONS

transpose

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

A^T B

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

A B^T

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

matrix action on a vector

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

matrix action on a vector

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

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

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

matrix-matrix product

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

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

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

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

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

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

isOrthogonalSM :: SpMatrix Double -> Bool

=== predicates

conditionNumberSM :: SpMatrix Double -> Double

=== condition number

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

=== Householder transformation

hhRefl :: SpVector Double -> SpMatrix Double

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

=== Givens rotation matrix

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

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

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

firstNonZeroColumn :: IntMap a -> Key -> Bool

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

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

=== QR algorithm

gmats :: SpMatrix Double -> [SpMatrix Double]

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

=== Eigenvalues, using QR

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

=== Eigenvalues, using Rayleigh iteration

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

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

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

eps :: Double

=== SVD

=================================================

LINEAR SOLVERS : solve A x = b

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

cgsStep :: SpMatrix Double -> SpVector Double -> CGS -> 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

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

BiCSSTAB

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

data LinSolveMethod

=== LINEAR SOLVERS INTERFACE

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)

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

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

sizeStr :: SpMatrix a -> String

TODO : if system is poorly conditioned, is it better to warn the user or just switch solvers (e.g. via the pseudoinverse) ?

=== PRETTY PRINTING

Show details and contents of sparse matrix

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 ()

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

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

tm0 :: SpMatrix Double

tm1 :: SpMatrix Double

tm2 :: SpMatrix Double

tm3 :: SpMatrix Double

tm4 :: SpMatrix Double

tv0 :: SpVector Double

tv1 :: SpVector Double

tm1g1 :: SpMatrix Double

tm1a2 :: SpMatrix Double

tm1g2 :: SpMatrix Double

tm1a3 :: SpMatrix Double

tm1q :: SpMatrix Double

tm3g1 :: SpMatrix Double

untilC :: (a -> Bool) -> Int -> (a -> a) -> a -> a

terminate after n iterations or when q becomes true, whichever comes first