Numeric.LinearAlgebra.Repa

HMatrix linear algebra functions wrapped to accept Repa arrays.

• Unqualified functions use raw F arrays.
• "-S" functions precompute D arrays sequentially.
• "-SIO" functions precompute D arrays sequentially in the IO monad.
• "-P" functions precompute D arrays in parralel in any monad.
• "-PIO" functions precompute D arrays in parralel in the IO monad.

Typeclasses

class (Container Vector t, Container Matrix t, Konst t Int Vector, Konst t (Int, Int) Matrix, CTrans t, Product t, Additive (Vector t), Additive (Matrix t), Linear t Vector, Linear t Matrix) => Numeric t

Instances

Numeric Double

Numeric Float

Numeric I

Numeric Z

Numeric (Complex Double)

Numeric (Complex Float)

KnownNat m => Numeric (Mod m I)

KnownNat m => Numeric (Mod m Z)

class (Numeric t, Convert t, Normed Matrix t, Normed Vector t, Floating t, Linear t Vector, Linear t Matrix, Additive (Vector t), Additive (Matrix t), (~) * (RealOf t) Double) => Field t

Generic linear algebra functions for double precision real and complex matrices.

(Single precision data can be converted using single and double).

Minimal complete definition

svd', thinSVD', sv', luPacked', luSolve', mbLinearSolve', linearSolve', cholSolve', ldlPacked', ldlSolve', linearSolveSVD', linearSolveLS', eig', eigSH'', eigOnly, eigOnlySH, cholSH', mbCholSH', qr', qrgr', hess', schur'

Instances

Field Double

Field (Complex Double)

class (Num e, Element e) => Product e

Matrix product and related functions

Minimal complete definition

multiply, absSum, norm1, norm2, normInf

Instances

Product Double

Product Float

Product I

Product Z

Product (Complex Double)

Product (Complex Float)

KnownNat m => Product (Mod m I)

KnownNat m => Product (Mod m Z)

class LSDiv c

Minimal complete definition

linSolve

Instances

LSDiv Matrix

LSDiv Vector

Shape-polymorphic conversion

class HShape sh where

Shape-polymorphic conversion.

Associated Types

type HType sh :: * -> *

Methods

toRepa :: Numeric t => HType sh t -> Array F sh t

fromRepa :: Numeric t => Array F sh t -> HType sh t

fromRepaS :: Numeric t => Array D sh t -> HType sh t

fromRepaSIO :: Numeric t => Array D sh t -> IO (HType sh t)

fromRepaP :: (Numeric t, Monad m) => Array D sh t -> m (HType sh t)

fromRepaPIO :: Numeric t => Array D sh t -> IO (HType sh t)

Instances

HShape DIM1

HShape DIM2

Data types

data Vector a :: * -> *

Storable-based vectors

Instances

LSDiv Vector

Complexable Vector

Normed Vector Double

Normed Vector Float

Container Vector Double

Container Vector Float

Container Vector I

Container Vector Z

Container Vector t => Linear t Vector

Storable a => Vector Vector a

Mul Matrix Vector Vector

Mul Vector Matrix Vector

Container Vector e => Konst e Int Vector

Normed Vector (Complex Double)

Normed Vector (Complex Float)

Container Vector (Complex Double)

Container Vector (Complex Float)

KnownNat m => Container Vector (Mod m I)

KnownNat m => Container Vector (Mod m Z)

Container Vector e => Build Int (e -> e) Vector e

Storable a => IsList (Vector a)

(Storable a, Eq a) => Eq (Vector a)

(Data a, Storable a) => Data (Vector a)

KnownNat m => Num (Vector (Mod m I))

KnownNat m => Num (Vector (Mod m Z))

(Storable a, Ord a) => Ord (Vector a)

(Read a, Storable a) => Read (Vector a)

(Show a, Storable a) => Show (Vector a)

Storable a => Monoid (Vector a)

NFData (Vector a)

Normed (Vector Float)

Normed (Vector (Complex Float))

KnownNat m => Normed (Vector (Mod m I))

KnownNat m => Normed (Vector (Mod m Z))

Normed (Vector I)

Normed (Vector Z)

Normed (Vector R)

Normed (Vector C)

Container Vector t => Additive (Vector t)

Storable t => TransArray (Vector t)

Indexable (Vector Double) Double

Indexable (Vector Float) Float

Indexable (Vector I) I

Indexable (Vector Z) Z

Element t => Indexable (Matrix t) (Vector t)

Indexable (Vector (Complex Double)) (Complex Double)

Indexable (Vector (Complex Float)) (Complex Float)

(Storable t, Indexable (Vector t) t) => Indexable (Vector (Mod m t)) (Mod m t)

type IndexOf Vector = Int

type Mutable Vector = MVector

type ArgOf Vector a = a -> a

type Item (Vector a) = a

type ElementOf (Vector a) = a

type TransRaw (Vector t) b = CInt -> Ptr t -> b

type Trans (Vector t) b = CInt -> Ptr t -> b

data Matrix t :: * -> *

Matrix representation suitable for BLAS/LAPACK computations.

Instances

LSDiv Matrix

Complexable Matrix

Normed Matrix Double

Normed Matrix Float

(Num a, Element a, Container Vector a) => Container Matrix a

Container Matrix t => Linear t Matrix

Mul Matrix Matrix Matrix

Mul Matrix Vector Vector

Mul Vector Matrix Vector

Normed Matrix (Complex Double)

Normed Matrix (Complex Float)

(Num e, Container Vector e) => Konst e (Int, Int) Matrix

(Storable t, NFData t) => NFData (Matrix t)

Normed (Matrix R)

Normed (Matrix C)

Container Matrix t => Additive (Matrix t)

KnownNat m => Testable (Matrix (Mod m I))

Storable t => TransArray (Matrix t)

Element t => Indexable (Matrix t) (Vector t)

(CTrans t, Container Vector t) => Transposable (Matrix t) (Matrix t)

Container Matrix e => Build (Int, Int) (e -> e -> e) Matrix e

type IndexOf Matrix = (Int, Int)

type ArgOf Matrix a = a -> a -> a

type ElementOf (Matrix a) = a

type TransRaw (Matrix t) b = CInt -> CInt -> Ptr t -> b

type Trans (Matrix t) b = CInt -> CInt -> CInt -> CInt -> Ptr t -> b

data RandDist :: *

Constructors

Uniform

uniform distribution in [0,1)

Gaussian

normal distribution with mean zero and standard deviation one

Instances

Enum RandDist

type Seed = Int

Special types

data Herm t :: * -> *

A matrix that, by construction, it is known to be complex Hermitian or real symmetric.

It can be created using sym, mTm, or trustSym, and the matrix can be extracted using unSym.

Instances

Field t => Linear t Herm

(Show t, Element t) => Show (Herm t)

(NFData t, Numeric t) => NFData (Herm t)

Field t => Additive (Herm t)

data LU t :: * -> *

LU decomposition of a matrix in a compact format.

Instances

(Show t, Element t) => Show (LU t)

(NFData t, Numeric t) => NFData (LU t)

data LDL t :: * -> *

LDL decomposition of a complex Hermitian or real symmetric matrix in a compact format.

Instances

(Show t, Element t) => Show (LDL t)

(NFData t, Numeric t) => NFData (LDL t)

Dot product

dot :: Numeric t => Array F DIM1 t -> Array F DIM1 t -> t

Vector dot product.

dotS :: Numeric t => Array D DIM1 t -> Array D DIM1 t -> t

Vector dot product. Arguments computed sequentially.

dotSIO :: Numeric t => Array D DIM1 t -> Array D DIM1 t -> IO t

Vector dot product. Arguments computed sequentially inside the IO monad.

dotP :: (Numeric t, Monad m) => Array D DIM1 t -> Array D DIM1 t -> m t

Vector dot product. Arguments computed in parallel.

dotPIO :: Numeric t => Array D DIM1 t -> Array D DIM1 t -> IO t

Vector dot product. Arguments computed in parallel inside the IO monad.

Dense matrix-vector product.

app :: Numeric t => Array F DIM2 t -> Array F DIM1 t -> Array F DIM1 t

Dense matrix-vector product.

appS :: Numeric t => Array D DIM2 t -> Array D DIM1 t -> Array F DIM1 t

Dense matrix-vector product. Arguments computed sequentially.

appSIO :: Numeric t => Array D DIM2 t -> Array D DIM1 t -> IO (Array F DIM1 t)

Dense matrix-vector product. Arguments computed sequentially inside the IO monad.

appP :: (Numeric t, Monad m) => Array D DIM2 t -> Array D DIM1 t -> m (Array F DIM1 t)

Dense matrix-vector product. Arguments computed in parallel.

appPIO :: Numeric t => Array D DIM2 t -> Array D DIM1 t -> IO (Array F DIM1 t)

Dense matrix-vector product. Arguments computed in parallel inside the IO monad.

Dense matrix-matrix product.

mul :: Numeric t => Array F DIM2 t -> Array F DIM2 t -> Array F DIM2 t

Dense matrix-matrix product.

mulS :: Numeric t => Array D DIM2 t -> Array D DIM2 t -> Array F DIM2 t

Dense matrix-matrix product. Arguments computed sequentially.

mulSIO :: Numeric t => Array D DIM2 t -> Array D DIM2 t -> IO (Array F DIM2 t)

Dense matrix-matrix product. Arguments computed sequentially inside the IO monad

mulP :: (Numeric t, Monad m) => Array D DIM2 t -> Array D DIM2 t -> m (Array F DIM2 t)

Dense matrix-matrix product. Arguments computed in parallel.

mulPIO :: Numeric t => Array D DIM2 t -> Array D DIM2 t -> IO (Array F DIM2 t)

Dense matrix-matrix product. Arguments computed in parallel inside the IO monad

Vector outer product.

outer :: (Product t, Numeric t) => Array F DIM1 t -> Array F DIM1 t -> Array F DIM2 t

Outer product of two vectors.

outerS :: (Product t, Numeric t) => Array D DIM1 t -> Array D DIM1 t -> Array F DIM2 t

Outer product of two vectors. Arguments computed sequentially.

outerSIO :: (Product t, Numeric t) => Array D DIM1 t -> Array D DIM1 t -> IO (Array F DIM2 t)

Outer product of two vectors. Arguments computed sequentially inside the IO monad.

outerP :: (Product t, Numeric t, Monad m) => Array D DIM1 t -> Array D DIM1 t -> m (Array F DIM2 t)

Outer product of two vectors. Arguments computed in parallel.

outerPIO :: (Product t, Numeric t) => Array D DIM1 t -> Array D DIM1 t -> IO (Array F DIM2 t)

Outer product of two vectors. Arguments computed in parallel inside the IO monad.

Kronecker product.

kronecker :: (Product t, Numeric t) => Array F DIM2 t -> Array F DIM2 t -> Array F DIM2 t

Kronecker product of two matrices.

kroneckerS :: (Product t, Numeric t) => Array D DIM2 t -> Array D DIM2 t -> Array F DIM2 t

Kronecker product of two matrices. Arguments computed sequentially.

kroneckerSIO :: (Product t, Numeric t) => Array D DIM2 t -> Array D DIM2 t -> IO (Array F DIM2 t)

Kronecker product of two matrices. Arguments computed sequentially inside the IO monad.

kroneckerP :: (Product t, Numeric t, Monad m) => Array D DIM2 t -> Array D DIM2 t -> m (Array F DIM2 t)

Kronecker product of two matrices. Arguments computed in parallel.

kroneckerPIO :: (Product t, Numeric t) => Array D DIM2 t -> Array D DIM2 t -> IO (Array F DIM2 t)

Kronecker product of two matrices. Arguments computed in parallel inside the IO monad.

Cross product.

cross :: Array F DIM1 Double -> Array F DIM1 Double -> Array F DIM1 Double

Vector cross product.

crossS :: Array D DIM1 Double -> Array D DIM1 Double -> Array F DIM1 Double

Vector cross product. Arguments computed sequentially.

crossSIO :: Array D DIM1 Double -> Array D DIM1 Double -> IO (Array F DIM1 Double)

Vector cross product. Arguments computed sequentially inside the IO monad.

Sum of elements.

sumElements :: (Numeric t, HShape sh, Container (HType sh) t) => Array F sh t -> t

Sum elements of a matrix or a vector.

sumElementsS :: (Numeric t, HShape sh, Container (HType sh) t) => Array D sh t -> t

Sum elements of a matrix or a vector. Argument computed sequentially.

sumElementsSIO :: (Numeric t, HShape sh, Container (HType sh) t) => Array D sh t -> IO t

Sum elements of a matrix or a vector. Argument computed sequentially in the IO monad.

sumElementsP :: (Numeric t, HShape sh, Container (HType sh) t, Monad m) => Array D sh t -> m t

Sum elements of a matrix or a vector. Argument computed in parallel.

sumElementsPIO :: (Numeric t, HShape sh, Container (HType sh) t) => Array D sh t -> IO t

Sum elements of a matrix or a vector. Argument computed in parallel in the IO monad.

Product of elements.

prodElements :: (Numeric t, HShape sh, Container (HType sh) t) => Array F sh t -> t

Multiply elements of a matrix or a vector.

prodElementsS :: (Numeric t, HShape sh, Container (HType sh) t) => Array D sh t -> t

Multiply elements of a matrix or a vector. Argument computed sequentially.

prodElementsSIO :: (Numeric t, HShape sh, Container (HType sh) t) => Array D sh t -> IO t

Multiply elements of a matrix or a vector. Argument computed sequentially inside the IO monad.

prodElementsP :: (Numeric t, HShape sh, Container (HType sh) t, Monad m) => Array D sh t -> m t

Multiply elements of a matrix or a vector. Argument computed in parallel.

prodElementsPIO :: (Numeric t, HShape sh, Container (HType sh) t) => Array D sh t -> IO t

Multiply elements of a matrix or a vector. Argument computed in parallel inside the IO monad.

Linear systems.

(<\>) :: (Field t, Numeric t, HShape sh, LSDiv (HType sh)) => Array F DIM2 t -> Array F sh t -> Array F sh t

Infix alias for solve.

solve :: (Field t, Numeric t, HShape sh, LSDiv (HType sh)) => Array F DIM2 t -> Array F sh t -> Array F sh t

Least squares solution of a linear system, similar to the operator of Matlab/Octave (based on linearSolveSD).

solveS :: (Field t, Numeric t, HShape sh, LSDiv (HType sh)) => Array D DIM2 t -> Array D sh t -> Array F sh t

Least squares solution of a linear system, similar to the operator of Matlab/Octave (based on linearSolveSD). Arguments are computed sequentially.

solveSIO :: (Field t, Numeric t, HShape sh, LSDiv (HType sh)) => Array D DIM2 t -> Array D sh t -> IO (Array F sh t)

Least squares solution of a linear system, similar to the operator of Matlab/Octave (based on linearSolveSD). Arguments are computed sequentially inside the IO monad.

solveP :: (Field t, Numeric t, HShape sh, LSDiv (HType sh), Monad m) => Array D DIM2 t -> Array D sh t -> m (Array F sh t)

Least squares solution of a linear system, similar to the operator of Matlab/Octave (based on linearSolveSD). Arguments are computed in parallel.

solvePIO :: (Field t, Numeric t, HShape sh, LSDiv (HType sh)) => Array D DIM2 t -> Array D sh t -> IO (Array F sh t)

Least squares solution of a linear system, similar to the operator of Matlab/Octave (based on linearSolveSD). Arguments are computed in parallel inside the IO monad.

linearSolve :: (Field t, Numeric t) => Array F DIM2 t -> Array F DIM2 t -> Maybe (Array F DIM2 t)

Solve a linear system (for square coefficient matrix and several right hand sides) using the LU decomposition, returning Nothing for a singular system. For underconstrained or overconstrained systems use linearSolveLS or linearSolveSVD.

linearSolveS :: (Field t, Numeric t) => Array D DIM2 t -> Array D DIM2 t -> Maybe (Array F DIM2 t)

Solve a linear system using the LU decomposition. Arguments computed sequentially.

linearSolveSIO :: (Field t, Numeric t) => Array D DIM2 t -> Array D DIM2 t -> IO (Maybe (Array F DIM2 t))

Solve a linear system using the LU decomposition. Arguments computed sequentially inside the IO monad.

linearSolveP :: (Field t, Numeric t, Monad m) => Array D DIM2 t -> Array D DIM2 t -> m (Maybe (Array F DIM2 t))

Solve a linear system using the LU decomposition. Arguments computed in parallel.

linearSolvePIO :: (Field t, Numeric t) => Array D DIM2 t -> Array D DIM2 t -> IO (Maybe (Array F DIM2 t))

Solve a linear system using the LU decomposition. Arguments computed in parallel inside the IO monad.

linearSolveLS :: (Field t, Numeric t) => Array F DIM2 t -> Array F DIM2 t -> Array F DIM2 t

Least squared error solution of an overcompensated system, or the minimum norm solution of an undercompensated system. For rank-deficient systems use linearSolveSVD.

linearSolveLS_S :: (Field t, Numeric t) => Array D DIM2 t -> Array D DIM2 t -> Array F DIM2 t

linearSolveLS_SIO :: (Field t, Numeric t) => Array D DIM2 t -> Array D DIM2 t -> IO (Array F DIM2 t)

linearSolveLS_P :: (Field t, Numeric t, Monad m) => Array D DIM2 t -> Array D DIM2 t -> m (Array F DIM2 t)

linearSolveLS_PIO :: (Field t, Numeric t) => Array D DIM2 t -> Array D DIM2 t -> IO (Array F DIM2 t)

linearSolveSVD :: (Field t, Numeric t) => Array F DIM2 t -> Array F DIM2 t -> Array F DIM2 t

Minimum norm solution of a general linear least squares problem Ax=b using the SVD. Admits rank-deficient systems but is slower than linearSolveLS. The effective rank of A is determined by treating as zero those singular values which are less than eps times the largest singular value.

linearSolveSVD_S :: (Field t, Numeric t) => Array D DIM2 t -> Array D DIM2 t -> Array F DIM2 t

linearSolveSVD_SIO :: (Field t, Numeric t) => Array D DIM2 t -> Array D DIM2 t -> IO (Array F DIM2 t)

linearSolveSVD_P :: (Field t, Numeric t, Monad m) => Array D DIM2 t -> Array D DIM2 t -> m (Array F DIM2 t)

linearSolveSVD_PIO :: (Field t, Numeric t) => Array D DIM2 t -> Array D DIM2 t -> IO (Array F DIM2 t)

luSolve :: (Field t, Numeric t) => LU t -> Array F DIM2 t -> Array F DIM2 t

Solution of a linear system (for several right hand sides) from the precomputed LU factorization obtained by luPacked.

luSolveS :: (Field t, Numeric t) => LU t -> Array D DIM2 t -> Array F DIM2 t

luSolveSIO :: (Field t, Numeric t) => LU t -> Array D DIM2 t -> IO (Array F DIM2 t)

luSolveP :: (Field t, Numeric t, Monad m) => LU t -> Array D DIM2 t -> m (Array F DIM2 t)

luSolvePIO :: (Field t, Numeric t) => LU t -> Array D DIM2 t -> IO (Array F DIM2 t)

cholSolve :: (Field t, Numeric t) => Array F DIM2 t -> Array F DIM2 t -> Array F DIM2 t

Solve a symmetric or Herimitian positive definite linear system using a precomputed Cholesky decomposition obtained by chol.

cholSolveS :: (Field t, Numeric t) => Array F DIM2 t -> Array D DIM2 t -> Array F DIM2 t

cholSolveSIO :: (Field t, Numeric t) => Array F DIM2 t -> Array D DIM2 t -> IO (Array F DIM2 t)

cholSolveP :: (Field t, Numeric t, Monad m) => Array F DIM2 t -> Array D DIM2 t -> m (Array F DIM2 t)

cholSolvePIO :: (Field t, Numeric t) => Array F DIM2 t -> Array D DIM2 t -> IO (Array F DIM2 t)

Inverse and pseudoinverse

inv :: (Field t, Numeric t) => Array F DIM2 t -> Array F DIM2 t

Inverse of a square matrix.

invS :: (Field t, Numeric t) => Array D DIM2 t -> Array F DIM2 t

invSIO :: (Field t, Numeric t) => Array D DIM2 t -> IO (Array F DIM2 t)

invP :: (Field t, Numeric t, Monad m) => Array D DIM2 t -> m (Array F DIM2 t)

invPIO :: (Field t, Numeric t) => Array D DIM2 t -> IO (Array F DIM2 t)

pinv :: (Field t, Numeric t) => Array F DIM2 t -> Array F DIM2 t

Pseudoinverse of a general matrix, with default tolerance (pinvTol 1, similar to GNU-Octave)

pinvS :: (Field t, Numeric t) => Array D DIM2 t -> Array F DIM2 t

pinvSIO :: (Field t, Numeric t) => Array D DIM2 t -> IO (Array F DIM2 t)

pinvP :: (Field t, Numeric t, Monad m) => Array D DIM2 t -> m (Array F DIM2 t)

pinvPIO :: (Field t, Numeric t) => Array D DIM2 t -> IO (Array F DIM2 t)

pinvTol :: (Field t, Numeric t) => Double -> Array F DIM2 t -> Array F DIM2 t

pinvTol r computes the pseudoinverse of a matrix with tolerance tol=r*g*eps*(max rows cols), where g is the greatest singular value.

pinvTolS :: (Field t, Numeric t) => Double -> Array D DIM2 t -> Array F DIM2 t

pinvTolSIO :: (Field t, Numeric t) => Double -> Array D DIM2 t -> IO (Array F DIM2 t)

pinvTolP :: (Field t, Numeric t, Monad m) => Double -> Array D DIM2 t -> m (Array F DIM2 t)

pinvTolPIO :: (Field t, Numeric t) => Double -> Array D DIM2 t -> IO (Array F DIM2 t)

Determinant and rank

rcond :: (Field t, Numeric t) => Array F DIM2 t -> Double

Reciprocal of the 2-norm condition number of a matrix, computed from the singular values.

rcondS :: (Field t, Numeric t) => Array D DIM2 t -> Double

rcondSIO :: (Field t, Numeric t) => Array D DIM2 t -> IO Double

rcondP :: (Field t, Numeric t, Monad m) => Array D DIM2 t -> m Double

rcondPIO :: (Field t, Numeric t) => Array D DIM2 t -> IO Double

rank :: (Field t, Numeric t) => Array F DIM2 t -> Int

Number of linearly independent rows or columns. See also ranksv.

rankS :: (Field t, Numeric t) => Array D DIM2 t -> Int

rankSIO :: (Field t, Numeric t) => Array D DIM2 t -> IO Int

rankP :: (Field t, Numeric t, Monad m) => Array D DIM2 t -> m Int

rankPIO :: (Field t, Numeric t) => Array D DIM2 t -> IO Int

det :: (Field t, Numeric t) => Array F DIM2 t -> t

Determinant of a square matrix. To avoid possible overflow or underflow use invlndet.

detS :: (Field t, Numeric t) => Array D DIM2 t -> t

detSIO :: (Field t, Numeric t) => Array D DIM2 t -> IO t

detP :: (Field t, Numeric t, Monad m) => Array D DIM2 t -> m t

detPIO :: (Field t, Numeric t) => Array D DIM2 t -> IO t

invlndet

Arguments

:: (Field t, Numeric t)

=> Array F DIM2 t

-> (Array F DIM2 t, (t, t))

(inverse, (log abs det, sign or phase of det)) ^Joint computation of inverse and logarithm of determinant of a square matrix.

invlndetS :: (Field t, Numeric t) => Array D DIM2 t -> (Array F DIM2 t, (t, t))

invlndetSIO :: (Field t, Numeric t) => Array D DIM2 t -> IO (Array F DIM2 t, (t, t))

invlndetP :: (Field t, Numeric t, Monad m) => Array D DIM2 t -> m (Array F DIM2 t, (t, t))

invlndetPIO :: (Field t, Numeric t) => Array D DIM2 t -> IO (Array F DIM2 t, (t, t))

Norms

norm_Frob :: (Normed (Vector t), Element t) => Array F DIM2 t -> Double

norm_FrobS :: (Normed (Vector t), Element t) => Array D DIM2 t -> Double

norm_FrobSIO :: (Normed (Vector t), Element t) => Array D DIM2 t -> IO Double

norm_FrobP :: (Normed (Vector t), Element t, Monad m) => Array D DIM2 t -> m Double

norm_FrobPIO :: (Normed (Vector t), Element t) => Array D DIM2 t -> IO Double

norm_nuclear :: (Field t, Numeric t) => Array F DIM2 t -> Double

norm_nuclearS :: (Field t, Numeric t) => Array D DIM2 t -> Double

norm_nuclearSIO :: (Field t, Numeric t) => Array D DIM2 t -> IO Double

norm_nuclearP :: (Field t, Numeric t, Monad m) => Array D DIM2 t -> m Double

norm_nuclearPIO :: (Field t, Numeric t) => Array D DIM2 t -> IO Double

Nullspace and range

orth :: (Field t, Numeric t) => Array F DIM2 t -> Array F DIM2 t

An orthonormal basis of the range space of a matrix. See also orthSVD.

orthS :: (Field t, Numeric t) => Array D DIM2 t -> Array F DIM2 t

orthSIO :: (Field t, Numeric t) => Array D DIM2 t -> IO (Array F DIM2 t)

orthP :: (Field t, Numeric t, Monad m) => Array D DIM2 t -> m (Array F DIM2 t)

orthPIO :: (Field t, Numeric t) => Array D DIM2 t -> IO (Array F DIM2 t)

nullspace :: (Field t, Numeric t) => Array F DIM2 t -> Array F DIM2 t

An orthonormal basis of the null space of a matrix. See also nullspaceSVD.

nullspaceS :: (Field t, Numeric t) => Array D DIM2 t -> Array F DIM2 t

nullspaceSIO :: (Field t, Numeric t) => Array D DIM2 t -> IO (Array F DIM2 t)

nullspaceP :: (Field t, Numeric t, Monad m) => Array D DIM2 t -> m (Array F DIM2 t)

nullspacePIO :: (Field t, Numeric t) => Array D DIM2 t -> IO (Array F DIM2 t)

null1 :: Array F DIM2 Double -> Array F DIM1 Double

Solution of an overconstrained homogenous linear system.

null1S :: Array D DIM2 Double -> Array F DIM1 Double

null1SIO :: Array D DIM2 Double -> IO (Array F DIM1 Double)

null1P :: Monad m => Array D DIM2 Double -> m (Array F DIM1 Double)

null1PIO :: Array D DIM2 Double -> IO (Array F DIM1 Double)

null1sym :: Herm Double -> Array F DIM1 Double

Solution of an overconstrained homogenous symmetric linear system.

SVD

svd :: (Field t, Numeric t) => Array F DIM2 t -> (Array F DIM2 t, Array F DIM1 Double, Array F DIM2 t)

Full singular value decomposition.

svdS :: (Field t, Numeric t) => Array D DIM2 t -> (Array F DIM2 t, Array F DIM1 Double, Array F DIM2 t)

svdSIO :: (Field t, Numeric t) => Array D DIM2 t -> IO (Array F DIM2 t, Array F DIM1 Double, Array F DIM2 t)

svdP :: (Field t, Numeric t, Monad m) => Array D DIM2 t -> m (Array F DIM2 t, Array F DIM1 Double, Array F DIM2 t)

svdPIO :: (Field t, Numeric t) => Array D DIM2 t -> IO (Array F DIM2 t, Array F DIM1 Double, Array F DIM2 t)

thinSVD :: (Field t, Numeric t) => Array F DIM2 t -> (Array F DIM2 t, Array F DIM1 Double, Array F DIM2 t)

A version of svd which returns only the min (rows m) (cols m) singular vectors of m. (u,s,v) = thinSVD m ==> m == u * diag s * tr v

thinSVD_S :: (Field t, Numeric t) => Array D DIM2 t -> (Array F DIM2 t, Array F DIM1 Double, Array F DIM2 t)

thinSVD_SIO :: (Field t, Numeric t) => Array D DIM2 t -> IO (Array F DIM2 t, Array F DIM1 Double, Array F DIM2 t)

thinSVD_P :: (Field t, Numeric t, Monad m) => Array D DIM2 t -> m (Array F DIM2 t, Array F DIM1 Double, Array F DIM2 t)

thinSVD_PIO :: (Field t, Numeric t) => Array D DIM2 t -> IO (Array F DIM2 t, Array F DIM1 Double, Array F DIM2 t)

compactSVD :: (Field t, Numeric t) => Array F DIM2 t -> (Array F DIM2 t, Array F DIM1 Double, Array F DIM2 t)

Similar to thinSVD, returning only the nonzero singular values and the corresponding singular vectors.

compactSVD_S :: (Field t, Numeric t) => Array D DIM2 t -> (Array F DIM2 t, Array F DIM1 Double, Array F DIM2 t)

compactSVD_SIO :: (Field t, Numeric t) => Array D DIM2 t -> IO (Array F DIM2 t, Array F DIM1 Double, Array F DIM2 t)

compactSVD_P :: (Field t, Numeric t, Monad m) => Array D DIM2 t -> m (Array F DIM2 t, Array F DIM1 Double, Array F DIM2 t)

compactSVD_PIO :: (Field t, Numeric t) => Array D DIM2 t -> IO (Array F DIM2 t, Array F DIM1 Double, Array F DIM2 t)

singularValues :: (Field t, Numeric t) => Array F DIM2 t -> Array F DIM1 Double

Singular values only.

singularValuesS :: (Field t, Numeric t) => Array D DIM2 t -> Array F DIM1 Double

singularValuesSIO :: (Field t, Numeric t) => Array D DIM2 t -> IO (Array F DIM1 Double)

singularValuesP :: (Field t, Numeric t, Monad m) => Array D DIM2 t -> m (Array F DIM1 Double)

singularValuesPIO :: (Field t, Numeric t) => Array D DIM2 t -> IO (Array F DIM1 Double)

leftSV :: (Field t, Numeric t) => Array F DIM2 t -> (Array F DIM2 t, Array F DIM1 Double)

Singular values and all left singular vectors (as columns).

leftSV_S :: (Field t, Numeric t) => Array D DIM2 t -> (Array F DIM2 t, Array F DIM1 Double)

leftSV_SIO :: (Field t, Numeric t) => Array D DIM2 t -> IO (Array F DIM2 t, Array F DIM1 Double)

leftSV_P :: (Field t, Numeric t, Monad m) => Array D DIM2 t -> m (Array F DIM2 t, Array F DIM1 Double)

leftSV_PIO :: (Field t, Numeric t) => Array D DIM2 t -> IO (Array F DIM2 t, Array F DIM1 Double)

rightSV :: (Field t, Numeric t) => Array F DIM2 t -> (Array F DIM1 Double, Array F DIM2 t)

Singular values and all right singular vectors (as columns).

rightSV_S :: (Field t, Numeric t) => Array D DIM2 t -> (Array F DIM1 Double, Array F DIM2 t)

rightSV_SIO :: (Field t, Numeric t) => Array D DIM2 t -> IO (Array F DIM1 Double, Array F DIM2 t)

rightSV_P :: (Field t, Numeric t, Monad m) => Array D DIM2 t -> m (Array F DIM1 Double, Array F DIM2 t)

rightSV_PIO :: (Field t, Numeric t) => Array D DIM2 t -> IO (Array F DIM1 Double, Array F DIM2 t)

Eigensystems

eig :: (Field t, Numeric t) => Array F DIM2 t -> (Array F DIM1 (Complex Double), Array F DIM2 (Complex Double))

Eigenvalues (not ordered) and eigenvectors (as columns) of a general square matrix. (s,v) = eig m ==> m * v = v == v <> diag s

eigS :: (Field t, Numeric t) => Array D DIM2 t -> (Array F DIM1 (Complex Double), Array F DIM2 (Complex Double))

eigSIO :: (Field t, Numeric t) => Array D DIM2 t -> IO (Array F DIM1 (Complex Double), Array F DIM2 (Complex Double))

eigP :: (Field t, Numeric t, Monad m) => Array D DIM2 t -> m (Array F DIM1 (Complex Double), Array F DIM2 (Complex Double))

eigPIO :: (Field t, Numeric t) => Array D DIM2 t -> IO (Array F DIM1 (Complex Double), Array F DIM2 (Complex Double))

eigSH :: (Field t, Numeric t) => Herm t -> (Array F DIM1 Double, Array F DIM2 t)

Eigenvalues and eigenvectors (as columns) of a complex hermitian or a real symmetric matrix, in descending order.

eigenvalues :: (Field t, Numeric t) => Array F DIM2 t -> Array F DIM1 (Complex Double)

Eigenvalues (not ordered) of a general square matrix.

eigenvaluesS :: (Field t, Numeric t) => Array D DIM2 t -> Array F DIM1 (Complex Double)

eigenvaluesSIO :: (Field t, Numeric t) => Array D DIM2 t -> IO (Array F DIM1 (Complex Double))

eigenvaluesP :: (Field t, Numeric t, Monad m) => Array D DIM2 t -> m (Array F DIM1 (Complex Double))

eigenvaluesPIO :: (Field t, Numeric t) => Array D DIM2 t -> IO (Array F DIM1 (Complex Double))

eigenvaluesSH :: (Field t, Numeric t) => Herm t -> Array F DIM1 Double

Eigenvalues (in descending order) of a complex hermitian or real symmetric matrix.

geigSH :: (Field t, Numeric t) => Herm t -> Herm t -> (Array F DIM1 Double, Array F DIM2 t)

Generalized symmetric positive definite eigensystem Av = IBv, for A and B symmetric, B positive definite.

QR

qr :: (Field t, Numeric t) => Array F DIM2 t -> (Array F DIM2 t, Array F DIM2 t)

QR factorization. (q,r) = qr m ==> m = q * r where q is unitary and r is upper triangular.

qrS :: (Field t, Numeric t) => Array D DIM2 t -> (Array F DIM2 t, Array F DIM2 t)

qrSIO :: (Field t, Numeric t) => Array D DIM2 t -> IO (Array F DIM2 t, Array F DIM2 t)

qrP :: (Field t, Numeric t, Monad m) => Array D DIM2 t -> m (Array F DIM2 t, Array F DIM2 t)

qrPIO :: (Field t, Numeric t) => Array D DIM2 t -> IO (Array F DIM2 t, Array F DIM2 t)

rq :: (Field t, Numeric t) => Array F DIM2 t -> (Array F DIM2 t, Array F DIM2 t)

RQ factorization. (r,q) = rq m ==> m = r * q where q is unitary and r is upper triangular.

rqS :: (Field t, Numeric t) => Array D DIM2 t -> (Array F DIM2 t, Array F DIM2 t)

rqSIO :: (Field t, Numeric t) => Array D DIM2 t -> IO (Array F DIM2 t, Array F DIM2 t)

rqP :: (Field t, Numeric t, Monad m) => Array D DIM2 t -> m (Array F DIM2 t, Array F DIM2 t)

rqPIO :: (Field t, Numeric t) => Array D DIM2 t -> IO (Array F DIM2 t, Array F DIM2 t)

qrRaw :: (Field t, Numeric t) => Array F DIM2 t -> QR t

qrRawS :: (Field t, Numeric t) => Array D DIM2 t -> QR t

qrRawSIO :: (Field t, Numeric t) => Array D DIM2 t -> IO (QR t)

qrRawP :: (Field t, Numeric t, Monad m) => Array D DIM2 t -> m (QR t)

qrRawPIO :: (Field t, Numeric t) => Array D DIM2 t -> IO (QR t)

qrgr :: (Field t, Numeric t) => Int -> QR t -> Array F DIM2 t

Generate a matrix with k othogonal columns from the output of qrRaw.

Cholesky

chol :: Field t => Herm t -> Array F DIM2 t

Cholesky factorization of a positive definite hermitian or symmetric matrix. c = chol m ==> m == c' * c where c is upper triangular.

mbChol :: Field t => Herm t -> Maybe (Array F DIM2 t)

Similar to chol, but instead of an error (e.g., caused by a matrix not positive definite) it returns Nothing.

Hessenberg

hess :: (Field t, Numeric t) => Array F DIM2 t -> (Array F DIM2 t, Array F DIM2 t)

Hessenberg factorization. (p,h) == hess m ==> p * h * p' where p is unitary and h is in upper Hessenberg form (zero entries below the first subdiagonal).

hessS :: (Field t, Numeric t) => Array D DIM2 t -> (Array F DIM2 t, Array F DIM2 t)

hessSIO :: (Field t, Numeric t) => Array D DIM2 t -> IO (Array F DIM2 t, Array F DIM2 t)

hessP :: (Field t, Numeric t, Monad m) => Array D DIM2 t -> m (Array F DIM2 t, Array F DIM2 t)

hessPIO :: (Field t, Numeric t) => Array D DIM2 t -> IO (Array F DIM2 t, Array F DIM2 t)

Schur

schur :: (Field t, Numeric t) => Array F DIM2 t -> (Array F DIM2 t, Array F DIM2 t)

Schur factorization. (u,s) = schur m ==> m == u * s * u' where u is unitary and s is a Schur matrix. A complex Schur matrix is upper triangular. A real Schur matrix is upper triangular in 2x2 blocks.

schurS :: (Field t, Numeric t) => Array D DIM2 t -> (Array F DIM2 t, Array F DIM2 t)

schurSIO :: (Field t, Numeric t) => Array D DIM2 t -> IO (Array F DIM2 t, Array F DIM2 t)

schurP :: (Field t, Numeric t, Monad m) => Array D DIM2 t -> m (Array F DIM2 t, Array F DIM2 t)

schurPIO :: (Field t, Numeric t) => Array D DIM2 t -> IO (Array F DIM2 t, Array F DIM2 t)

LU

lu :: (Field t, Numeric t) => Array F DIM2 t -> (Array F DIM2 t, Array F DIM2 t, Array F DIM2 t, t)

Explicit LU factorization of a general matrix. (l,u,p,s) = lu m ==> m = p * l * u where l is lower triangular, u is upper triangular, p is a permutation matrix, and s is the signature of the permutation.

luS :: (Field t, Numeric t) => Array D DIM2 t -> (Array F DIM2 t, Array F DIM2 t, Array F DIM2 t, t)

luSIO :: (Field t, Numeric t) => Array D DIM2 t -> IO (Array F DIM2 t, Array F DIM2 t, Array F DIM2 t, t)

luP :: (Field t, Numeric t, Monad m) => Array D DIM2 t -> m (Array F DIM2 t, Array F DIM2 t, Array F DIM2 t, t)

luPIO :: (Field t, Numeric t) => Array D DIM2 t -> IO (Array F DIM2 t, Array F DIM2 t, Array F DIM2 t, t)

luPacked :: (Field t, Numeric t) => Array F DIM2 t -> LU t

Obtains the LU decomposition in a packed data structure suitable for luSolve.

luPackedS :: (Field t, Numeric t) => Array D DIM2 t -> LU t

luPackedSIO :: (Field t, Numeric t) => Array D DIM2 t -> IO (LU t)

luPackedP :: (Field t, Numeric t, Monad m) => Array D DIM2 t -> m (LU t)

luPackedPIO :: (Field t, Numeric t) => Array D DIM2 t -> IO (LU t)

luFact :: Numeric t => LU t -> (Array F DIM2 t, Array F DIM2 t, Array F DIM2 t, t)

Compute the explicit LU decomposition from the compact one obtained by luPacked.

Symmetric indefinite

ldlSolve :: Field t => LDL t -> Array F DIM2 t -> Array F DIM2 t

Solution of a linear system (for several right hand sides) from a precomputed LDL factorization obtained by ldlPacked. Note: this can be slower than the general solver based on the LU decomposition.

ldlSolveS :: Field t => LDL t -> Array D DIM2 t -> Array F DIM2 t

ldlSolveSIO :: Field t => LDL t -> Array D DIM2 t -> IO (Array F DIM2 t)

ldlSolveP :: (Field t, Monad m) => LDL t -> Array D DIM2 t -> m (Array F DIM2 t)

ldlSolvePIO :: Field t => LDL t -> Array D DIM2 t -> IO (Array F DIM2 t)

ldlPacked :: Field t => Herm t -> LDL t

Obtains the LDL decomposition of a matrix in a compact data structure suitable for ldlSolve.

Matrix functions

expm :: (Field t, Numeric t) => Array F DIM2 t -> Array F DIM2 t

Matrix exponential. It uses a direct translation of Algorithm 11.3.1 in Golub & Val Loan, based on a scaled Pade approximation.

expmS :: (Field t, Numeric t) => Array D DIM2 t -> Array F DIM2 t

expmSIO :: (Field t, Numeric t) => Array D DIM2 t -> IO (Array F DIM2 t)

expmP :: (Field t, Numeric t, Monad m) => Array D DIM2 t -> m (Array F DIM2 t)

expmPIO :: (Field t, Numeric t) => Array D DIM2 t -> IO (Array F DIM2 t)

sqrtm :: (Field t, Numeric t) => Array F DIM2 t -> Array F DIM2 t

Matrix square root. Currently it uses a simple iterative algorithm described in Wikipedia. It only works with invertible matrices that have a real solution.

sqrtmS :: (Field t, Numeric t) => Array D DIM2 t -> Array F DIM2 t

sqrtmSIO :: (Field t, Numeric t) => Array D DIM2 t -> IO (Array F DIM2 t)

sqrtmP :: (Field t, Numeric t, Monad m) => Array D DIM2 t -> m (Array F DIM2 t)

sqrtmPIO :: (Field t, Numeric t) => Array D DIM2 t -> IO (Array F DIM2 t)

matFunc :: (Complex Double -> Complex Double) -> Array F DIM2 (Complex Double) -> Array F DIM2 (Complex Double)

matFuncS :: (Complex Double -> Complex Double) -> Array D DIM2 (Complex Double) -> Array F DIM2 (Complex Double)

matFuncSIO :: (Complex Double -> Complex Double) -> Array D DIM2 (Complex Double) -> IO (Array F DIM2 (Complex Double))

matFuncP :: Monad m => (Complex Double -> Complex Double) -> Array D DIM2 (Complex Double) -> m (Array F DIM2 (Complex Double))

matFuncPIO :: (Complex Double -> Complex Double) -> Array D DIM2 (Complex Double) -> IO (Array F DIM2 (Complex Double))

Correlation and convolution

corr :: (Product t, Numeric t) => Array F DIM1 t -> Array F DIM1 t -> Array F DIM1 t

Correlation.

corrS :: (Product t, Numeric t) => Array F DIM1 t -> Array D DIM1 t -> Array F DIM1 t

corrSIO :: (Product t, Numeric t) => Array F DIM1 t -> Array D DIM1 t -> IO (Array F DIM1 t)

corrP :: (Product t, Numeric t, Monad m) => Array F DIM1 t -> Array D DIM1 t -> m (Array F DIM1 t)

corrPIO :: (Product t, Numeric t) => Array F DIM1 t -> Array D DIM1 t -> IO (Array F DIM1 t)

conv :: (Product t, Numeric t) => Array F DIM1 t -> Array F DIM1 t -> Array F DIM1 t

Convolution - corr with reversed kernel and padded input, equivalent to polynomial multiplication.

convS :: (Product t, Numeric t) => Array F DIM1 t -> Array D DIM1 t -> Array F DIM1 t

convSIO :: (Product t, Numeric t) => Array F DIM1 t -> Array D DIM1 t -> IO (Array F DIM1 t)

convP :: (Product t, Numeric t, Monad m) => Array F DIM1 t -> Array D DIM1 t -> m (Array F DIM1 t)

convPIO :: (Product t, Numeric t) => Array F DIM1 t -> Array D DIM1 t -> IO (Array F DIM1 t)

corrMin :: (Product t, Numeric t, RealElement t) => Array F DIM1 t -> Array F DIM1 t -> Array F DIM1 t

Similar to corr but using min instead of (*).

corrMinS :: (Product t, Numeric t, RealElement t) => Array F DIM1 t -> Array D DIM1 t -> Array F DIM1 t

corrMinSIO :: (Product t, Numeric t, RealElement t) => Array F DIM1 t -> Array D DIM1 t -> IO (Array F DIM1 t)

corrMinP :: (Product t, Numeric t, RealElement t, Monad m) => Array F DIM1 t -> Array D DIM1 t -> m (Array F DIM1 t)

corrMinPIO :: (Product t, Numeric t, RealElement t) => Array F DIM1 t -> Array D DIM1 t -> IO (Array F DIM1 t)

corr2 :: (Product t, Numeric t) => Array F DIM2 t -> Array F DIM2 t -> Array F DIM2 t

2D correlation (without padding).

corr2S :: (Product t, Numeric t) => Array F DIM2 t -> Array D DIM2 t -> Array F DIM2 t

corr2SIO :: (Product t, Numeric t) => Array F DIM2 t -> Array D DIM2 t -> IO (Array F DIM2 t)

corr2P :: (Product t, Numeric t, Monad m) => Array F DIM2 t -> Array D DIM2 t -> m (Array F DIM2 t)

corr2PIO :: (Product t, Numeric t) => Array F DIM2 t -> Array D DIM2 t -> IO (Array F DIM2 t)

conv2 :: (Product t, Numeric t, Num (Vector t)) => Array F DIM2 t -> Array F DIM2 t -> Array F DIM2 t

2D convolution.

conv2S :: (Product t, Numeric t, Num (Vector t)) => Array F DIM2 t -> Array D DIM2 t -> Array F DIM2 t

conv2SIO :: (Product t, Numeric t, Num (Vector t)) => Array F DIM2 t -> Array D DIM2 t -> IO (Array F DIM2 t)

conv2P :: (Product t, Numeric t, Num (Vector t), Monad m) => Array F DIM2 t -> Array D DIM2 t -> m (Array F DIM2 t)

conv2PIO :: (Product t, Numeric t, Num (Vector t)) => Array F DIM2 t -> Array D DIM2 t -> IO (Array F DIM2 t)

Random vectors and matrices

randomVector :: Seed -> RandDist -> Int -> Array F DIM1 Double

Pseudorandom vector of na given size. Usee randomIO to get a random seed.

randomMatrix :: RandDist -> Int -> Int -> IO (Array F DIM2 Double)

gaussianSample :: Seed -> Int -> Array F DIM1 Double -> Array F DIM2 Double -> Array F DIM2 Double

A matrix whose rows are pseudorandom samples from a multivariate Gaussian distribution.

uniformSample :: Seed -> Int -> [(Double, Double)] -> Array F DIM2 Double

A matrix whose rows are pseudorandom samples from a multivariate uniform distribution.

Misc

meanCov :: Array F DIM2 Double -> (Array F DIM1 Double, Array F DIM2 Double)

Compute mean vector and a covariance matrix of the rows of a matrix.

rowOuters :: Array F DIM2 Double -> Array F DIM2 Double -> Array F DIM2 Double

Outer product of the rows of the matrices.

sym :: Field t => Array F DIM2 t -> Herm t

Compute the complex Hermitian or real symmetric part of a square matrix ((x + tr x)/2).

symS :: Field t => Array D DIM2 t -> Herm t

symSIO :: Field t => Array D DIM2 t -> IO (Herm t)

symP :: (Field t, Monad m) => Array D DIM2 t -> m (Herm t)

symPIO :: Field t => Array D DIM2 t -> IO (Herm t)

mTm :: Field t => Array F DIM2 t -> Herm t

Compute the contraction tr x <> x of a general matrix.

mTmS :: Field t => Array D DIM2 t -> Herm t

mTmSIO :: Field t => Array D DIM2 t -> IO (Herm t)

mTmP :: (Field t, Monad m) => Array D DIM2 t -> m (Herm t)

mTmPIO :: Field t => Array D DIM2 t -> IO (Herm t)

trustSym :: Field t => Array F DIM2 t -> Herm t

At your own risk, declare that a matrix is complex Hermitian or real symmetric for usage in chol, eigSH, etc. Only a triangular part of the matrix will be used.

trustSymS :: Field t => Array D DIM2 t -> Herm t

trustSymSIO :: Field t => Array D DIM2 t -> IO (Herm t)

trustSymP :: (Field t, Monad m) => Array D DIM2 t -> m (Herm t)

trustSymPIO :: Field t => Array D DIM2 t -> IO (Herm t)

unSym :: Numeric t => Herm t -> Array F DIM2 t

Extract the general matrix from a Herm structure, forgetting its symmetric or Hermitian property.