Numeric.LinearAlgebra.Repa

Documentation

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

Instances

Numeric Double

Numeric Float

Numeric (Complex Double)

Numeric (Complex Float)

class (Product t, Convert t, Container Vector t, Container Matrix t, Normed Matrix t, Normed Vector t, Floating t, (~) * (RealOf t) Double) => Field t

Minimal complete definition

svd', thinSVD', sv', luPacked', luSolve', mbLinearSolve', linearSolve', cholSolve', 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

Minimal complete definition

multiply, absSum, norm1, norm2, normInf

Instances

Product Double

Product Float

Product (Complex Double)

Product (Complex Float)

data RandDist :: *

Constructors

Uniform

Gaussian

Instances

Enum RandDist

type Seed = Int

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

class LSDiv c

Minimal complete definition

linSolve

Instances

LSDiv Vector

LSDiv Matrix

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) => PackedLU 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) => PackedLU t -> Array D DIM2 t -> Array F DIM2 t

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

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

luSolvePIO :: (Field t, Numeric t) => PackedLU 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 :: Array F DIM2 Double -> Array F DIM1 Double

Solution of an overconstrained homogenous symmetric linear system.

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

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

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

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

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) => Array F DIM2 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.

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

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

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

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

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

Similar to eigSH without checking that the input matrix is hermitian or symmetric. It works with the upper triangular part.

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

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

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

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

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) => Array F DIM2 t -> Array F DIM1 Double

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

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

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

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

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

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

Similar to eigenvaluesSH without checking that the input matrix is hermitian or symmetric. It works with the upper triangular part.

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

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

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

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

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

Generalized symmetric positive definite eigensystem Av = IBv, for A and B symmetric, B positive definite (conditions not checked).

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

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

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

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

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 -> (Array F DIM2 t, Array F DIM1 t)

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

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

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

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

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

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

Cholesky

chol :: (Field t, Numeric t) => Array F DIM2 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.

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

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

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

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

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

Similar to chol without checking that the input matrix is hermitian or symmetric. It works with the upper triangular part.

chol'S :: (Field t, Numeric t) => Array D DIM2 t -> Array F DIM2 t

chol'SIO :: (Field t, Numeric t) => Array D DIM2 t -> IO (Array F DIM2 t)

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

chol'PIO :: (Field t, Numeric t) => Array D DIM2 t -> IO (Array F DIM2 t)

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 -> PackedLU t

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

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

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

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

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

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.