Numeric.LinearAlgebra.Static

Experimental interface with statically checked dimensions.

See code examples at http://dis.um.es/~alberto/hmatrix/static.html.

Vector

type ℝ = Double

data R n

Instances

Domain ℝ R L

Methods

mul :: (KnownNat m, KnownNat k, KnownNat n) => L m k -> L k n -> L m n

app :: (KnownNat m, KnownNat n) => L m n -> R n -> R m

dot :: KnownNat n => R n -> R n -> ℝ

cross :: R 3 -> R 3 -> R 3

diagR :: (KnownNat m, KnownNat n, KnownNat k) => ℝ -> R k -> L m n

KnownNat n => Sized ℝ (R n) Vector

Methods

konst :: ℝ -> R n

unwrap :: R n -> Vector ℝ

fromList :: [ℝ] -> R n

extract :: R n -> Vector ℝ

create :: Vector ℝ -> Maybe (R n)

size :: R n -> IndexOf Vector

Floating (R n)

Methods

pi :: R n

exp :: R n -> R n

log :: R n -> R n

sqrt :: R n -> R n

(**) :: R n -> R n -> R n

logBase :: R n -> R n -> R n

sin :: R n -> R n

cos :: R n -> R n

tan :: R n -> R n

asin :: R n -> R n

acos :: R n -> R n

atan :: R n -> R n

sinh :: R n -> R n

cosh :: R n -> R n

tanh :: R n -> R n

asinh :: R n -> R n

acosh :: R n -> R n

atanh :: R n -> R n

log1p :: R n -> R n

expm1 :: R n -> R n

log1pexp :: R n -> R n

log1mexp :: R n -> R n

Fractional (R n)

Methods

(/) :: R n -> R n -> R n

recip :: R n -> R n

fromRational :: Rational -> R n

Num (R n)

Methods

(+) :: R n -> R n -> R n

(-) :: R n -> R n -> R n

(*) :: R n -> R n -> R n

negate :: R n -> R n

abs :: R n -> R n

signum :: R n -> R n

fromInteger :: Integer -> R n

KnownNat n => Show (R n)

Methods

showsPrec :: Int -> R n -> ShowS

show :: R n -> String

showList :: [R n] -> ShowS

KnownNat n => Disp (R n)

Methods

disp :: Int -> R n -> IO ()

KnownNat n => Eigen (Sym n) (R n) (L n n)

Methods

eigensystem :: Sym n -> (R n, L n n)

eigenvalues :: Sym n -> R n

(KnownNat m, KnownNat n, (<=) n ((+) m 1)) => Diag (L m n) (R n)

Methods

takeDiag :: L m n -> R n

(KnownNat m, KnownNat n, (<=) m ((+) n 1)) => Diag (L m n) (R m)

Methods

takeDiag :: L m n -> R m

KnownNat n => Diag (L n n) (R n)

Methods

takeDiag :: L n n -> R n

vec2 :: ℝ -> ℝ -> R 2

vec3 :: ℝ -> ℝ -> ℝ -> R 3

vec4 :: ℝ -> ℝ -> ℝ -> ℝ -> R 4

(&) :: forall n. (KnownNat n, 1 <= n) => R n -> ℝ -> R (n + 1) infixl 4

(#) :: forall n m. (KnownNat n, KnownNat m) => R n -> R m -> R (n + m) infixl 4

split :: forall p n. (KnownNat p, KnownNat n, p <= n) => R n -> (R p, R (n - p))

headTail :: (KnownNat n, 1 <= n) => R n -> (ℝ, R (n - 1))

vector :: KnownNat n => [ℝ] -> R n

linspace :: forall n. KnownNat n => (ℝ, ℝ) -> R n

range :: forall n. KnownNat n => R n

dim :: forall n. KnownNat n => R n

Matrix

data L m n

Instances

Domain ℝ R L

Methods

mul :: (KnownNat m, KnownNat k, KnownNat n) => L m k -> L k n -> L m n

app :: (KnownNat m, KnownNat n) => L m n -> R n -> R m

dot :: KnownNat n => R n -> R n -> ℝ

cross :: R 3 -> R 3 -> R 3

diagR :: (KnownNat m, KnownNat n, KnownNat k) => ℝ -> R k -> L m n

(KnownNat m, KnownNat n) => Sized ℝ (L m n) Matrix

Methods

konst :: ℝ -> L m n

unwrap :: L m n -> Matrix ℝ

fromList :: [ℝ] -> L m n

extract :: L m n -> Matrix ℝ

create :: Matrix ℝ -> Maybe (L m n)

size :: L m n -> IndexOf Matrix

KnownNat n => Eigen (Sym n) (R n) (L n n)

Methods

eigensystem :: Sym n -> (R n, L n n)

eigenvalues :: Sym n -> R n

KnownNat n => Eigen (Sq n) (C n) (M n n)

Methods

eigensystem :: Sq n -> (C n, M n n)

eigenvalues :: Sq n -> C n

(KnownNat n, KnownNat m) => Floating (L n m)

Methods

pi :: L n m

exp :: L n m -> L n m

log :: L n m -> L n m

sqrt :: L n m -> L n m

(**) :: L n m -> L n m -> L n m

logBase :: L n m -> L n m -> L n m

sin :: L n m -> L n m

cos :: L n m -> L n m

tan :: L n m -> L n m

asin :: L n m -> L n m

acos :: L n m -> L n m

atan :: L n m -> L n m

sinh :: L n m -> L n m

cosh :: L n m -> L n m

tanh :: L n m -> L n m

asinh :: L n m -> L n m

acosh :: L n m -> L n m

atanh :: L n m -> L n m

log1p :: L n m -> L n m

expm1 :: L n m -> L n m

log1pexp :: L n m -> L n m

log1mexp :: L n m -> L n m

(KnownNat n, KnownNat m) => Fractional (L n m)

Methods

(/) :: L n m -> L n m -> L n m

recip :: L n m -> L n m

fromRational :: Rational -> L n m

(KnownNat n, KnownNat m) => Num (L n m)

Methods

(+) :: L n m -> L n m -> L n m

(-) :: L n m -> L n m -> L n m

(*) :: L n m -> L n m -> L n m

negate :: L n m -> L n m

abs :: L n m -> L n m

signum :: L n m -> L n m

fromInteger :: Integer -> L n m

(KnownNat m, KnownNat n) => Show (L m n)

Methods

showsPrec :: Int -> L m n -> ShowS

show :: L m n -> String

showList :: [L m n] -> ShowS

(KnownNat m, KnownNat n) => Disp (L m n)

Methods

disp :: Int -> L m n -> IO ()

(KnownNat m, KnownNat n, (<=) n ((+) m 1)) => Diag (L m n) (R n)

Methods

takeDiag :: L m n -> R n

(KnownNat m, KnownNat n, (<=) m ((+) n 1)) => Diag (L m n) (R m)

Methods

takeDiag :: L m n -> R m

KnownNat n => Diag (L n n) (R n)

Methods

takeDiag :: L n n -> R n

(KnownNat n, KnownNat m) => Transposable (L m n) (L n m)

Methods

tr :: L m n -> L n m

tr' :: L m n -> L n m

type Sq n = L n n

build :: forall m n. (KnownNat n, KnownNat m) => (ℝ -> ℝ -> ℝ) -> L m n

row :: R n -> L 1 n

col :: KnownNat n => R n -> L n 1

(|||) :: (KnownNat ((+) r1 r2), KnownNat c, KnownNat r2, KnownNat r1) => L c r1 -> L c r2 -> L c ((+) r1 r2) infixl 3

(===) :: (KnownNat r1, KnownNat r2, KnownNat c) => L r1 c -> L r2 c -> L (r1 + r2) c infixl 2

splitRows :: forall p m n. (KnownNat p, KnownNat m, KnownNat n, p <= m) => L m n -> (L p n, L (m - p) n)

splitCols :: forall p m n. (KnownNat p, KnownNat m, KnownNat n, KnownNat (n - p), p <= n) => L m n -> (L m p, L m (n - p))

unrow :: L 1 n -> R n

uncol :: KnownNat n => L n 1 -> R n

tr :: Transposable m mt => m -> mt

conjugate transpose

eye :: KnownNat n => Sq n

diag :: KnownNat n => R n -> Sq n

blockAt :: forall m n. (KnownNat m, KnownNat n) => ℝ -> Int -> Int -> Matrix Double -> L m n

matrix :: (KnownNat m, KnownNat n) => [ℝ] -> L m n

Complex

data C n

Instances

Floating (C n)

Methods

pi :: C n

exp :: C n -> C n

log :: C n -> C n

sqrt :: C n -> C n

(**) :: C n -> C n -> C n

logBase :: C n -> C n -> C n

sin :: C n -> C n

cos :: C n -> C n

tan :: C n -> C n

asin :: C n -> C n

acos :: C n -> C n

atan :: C n -> C n

sinh :: C n -> C n

cosh :: C n -> C n

tanh :: C n -> C n

asinh :: C n -> C n

acosh :: C n -> C n

atanh :: C n -> C n

log1p :: C n -> C n

expm1 :: C n -> C n

log1pexp :: C n -> C n

log1mexp :: C n -> C n

Fractional (C n)

Methods

(/) :: C n -> C n -> C n

recip :: C n -> C n

fromRational :: Rational -> C n

Num (C n)

Methods

(+) :: C n -> C n -> C n

(-) :: C n -> C n -> C n

(*) :: C n -> C n -> C n

negate :: C n -> C n

abs :: C n -> C n

signum :: C n -> C n

fromInteger :: Integer -> C n

KnownNat n => Show (C n)

Methods

showsPrec :: Int -> C n -> ShowS

show :: C n -> String

showList :: [C n] -> ShowS

KnownNat n => Disp (C n)

Methods

disp :: Int -> C n -> IO ()

KnownNat n => Eigen (Sq n) (C n) (M n n)

Methods

eigensystem :: Sq n -> (C n, M n n)

eigenvalues :: Sq n -> C n

data M m n

Instances

KnownNat n => Eigen (Sq n) (C n) (M n n)

Methods

eigensystem :: Sq n -> (C n, M n n)

eigenvalues :: Sq n -> C n

(KnownNat n, KnownNat m) => Floating (M n m)

Methods

pi :: M n m

exp :: M n m -> M n m

log :: M n m -> M n m

sqrt :: M n m -> M n m

(**) :: M n m -> M n m -> M n m

logBase :: M n m -> M n m -> M n m

sin :: M n m -> M n m

cos :: M n m -> M n m

tan :: M n m -> M n m

asin :: M n m -> M n m

acos :: M n m -> M n m

atan :: M n m -> M n m

sinh :: M n m -> M n m

cosh :: M n m -> M n m

tanh :: M n m -> M n m

asinh :: M n m -> M n m

acosh :: M n m -> M n m

atanh :: M n m -> M n m

log1p :: M n m -> M n m

expm1 :: M n m -> M n m

log1pexp :: M n m -> M n m

log1mexp :: M n m -> M n m

(KnownNat n, KnownNat m) => Fractional (M n m)

Methods

(/) :: M n m -> M n m -> M n m

recip :: M n m -> M n m

fromRational :: Rational -> M n m

(KnownNat n, KnownNat m) => Num (M n m)

Methods

(+) :: M n m -> M n m -> M n m

(-) :: M n m -> M n m -> M n m

(*) :: M n m -> M n m -> M n m

negate :: M n m -> M n m

abs :: M n m -> M n m

signum :: M n m -> M n m

fromInteger :: Integer -> M n m

(KnownNat m, KnownNat n) => Show (M m n)

Methods

showsPrec :: Int -> M m n -> ShowS

show :: M m n -> String

showList :: [M m n] -> ShowS

(KnownNat m, KnownNat n) => Disp (M m n)

Methods

disp :: Int -> M m n -> IO ()

(KnownNat n, KnownNat m) => Transposable (M m n) (M n m)

Methods

tr :: M m n -> M n m

tr' :: M m n -> M n m

data Her n

her :: KnownNat n => M n n -> Her n

𝑖 :: Sized ℂ s c => s

Products

(<>) :: forall m k n. (KnownNat m, KnownNat k, KnownNat n) => L m k -> L k n -> L m n infixr 8

(#>) :: (KnownNat m, KnownNat n) => L m n -> R n -> R m infixr 8

(<.>) :: R n -> R n -> ℝ infixr 8

Linear Systems

linSolve :: (KnownNat m, KnownNat n) => L m m -> L m n -> Maybe (L m n)

(<\>) :: (KnownNat m, KnownNat n, KnownNat r) => L m n -> L m r -> L n r

Factorizations

svd :: (KnownNat m, KnownNat n) => L m n -> (L m m, R n, L n n)

withCompactSVD :: forall m n z. (KnownNat m, KnownNat n) => L m n -> (forall k. KnownNat k => (L m k, R k, L n k) -> z) -> z

svdTall :: (KnownNat m, KnownNat n, n <= m) => L m n -> (L m n, R n, L n n)

svdFlat :: (KnownNat m, KnownNat n, m <= n) => L m n -> (L m m, R m, L n m)

class Eigen m l v | m -> l, m -> v where

Minimal complete definition

eigensystem, eigenvalues

Methods

eigensystem :: m -> (l, v)

eigenvalues :: m -> l

Instances

KnownNat n => Eigen (Sym n) (R n) (L n n)

Methods

eigensystem :: Sym n -> (R n, L n n)

eigenvalues :: Sym n -> R n

KnownNat n => Eigen (Sq n) (C n) (M n n)

Methods

eigensystem :: Sq n -> (C n, M n n)

eigenvalues :: Sq n -> C n

withNullspace :: forall m n z. (KnownNat m, KnownNat n) => L m n -> (forall k. KnownNat k => L n k -> z) -> z

qr :: (KnownNat m, KnownNat n) => L m n -> (L m m, L m n)

chol :: KnownNat n => Sym n -> Sq n

Misc

mean :: (KnownNat n, 1 <= n) => R n -> ℝ

class Disp t where

Minimal complete definition

disp

Methods

disp :: Int -> t -> IO ()

Instances

KnownNat n => Disp (C n)

Methods

disp :: Int -> C n -> IO ()

KnownNat n => Disp (R n)

Methods

disp :: Int -> R n -> IO ()

(KnownNat m, KnownNat n) => Disp (M m n)

Methods

disp :: Int -> M m n -> IO ()

(KnownNat m, KnownNat n) => Disp (L m n)

Methods

disp :: Int -> L m n -> IO ()

class Domain field vec mat | mat -> vec field, vec -> mat field, field -> mat vec where

Minimal complete definition

mul, app, dot, cross, diagR

Methods

mul :: forall m k n. (KnownNat m, KnownNat k, KnownNat n) => mat m k -> mat k n -> mat m n

app :: forall m n. (KnownNat m, KnownNat n) => mat m n -> vec n -> vec m

dot :: forall n. KnownNat n => vec n -> vec n -> field

cross :: vec 3 -> vec 3 -> vec 3

diagR :: forall m n k. (KnownNat m, KnownNat n, KnownNat k) => field -> vec k -> mat m n

Instances

Domain ℝ R L

Methods

mul :: (KnownNat m, KnownNat k, KnownNat n) => L m k -> L k n -> L m n

app :: (KnownNat m, KnownNat n) => L m n -> R n -> R m

dot :: KnownNat n => R n -> R n -> ℝ

cross :: R 3 -> R 3 -> R 3

diagR :: (KnownNat m, KnownNat n, KnownNat k) => ℝ -> R k -> L m n

withVector :: forall z. Vector ℝ -> (forall n. KnownNat n => R n -> z) -> z

withMatrix :: forall z. Matrix ℝ -> (forall m n. (KnownNat m, KnownNat n) => L m n -> z) -> z

toRows :: forall m n. (KnownNat m, KnownNat n) => L m n -> [R n]

toColumns :: forall m n. (KnownNat m, KnownNat n) => L m n -> [R m]

class Num t => Sized t s d | s -> t, s -> d where

Minimal complete definition

konst, unwrap, fromList, extract, create, size

Methods

konst :: t -> s

unwrap :: s -> d t

fromList :: [t] -> s

extract :: s -> d t

create :: d t -> Maybe s

size :: s -> IndexOf d

Instances

KnownNat n => Sized ℝ (R n) Vector

Methods

konst :: ℝ -> R n

unwrap :: R n -> Vector ℝ

fromList :: [ℝ] -> R n

extract :: R n -> Vector ℝ

create :: Vector ℝ -> Maybe (R n)

size :: R n -> IndexOf Vector

(KnownNat m, KnownNat n) => Sized ℝ (L m n) Matrix

Methods

konst :: ℝ -> L m n

unwrap :: L m n -> Matrix ℝ

fromList :: [ℝ] -> L m n

extract :: L m n -> Matrix ℝ

create :: Matrix ℝ -> Maybe (L m n)

size :: L m n -> IndexOf Matrix

class Diag m d | m -> d where

Minimal complete definition

takeDiag

Methods

takeDiag :: m -> d

Instances

(KnownNat m, KnownNat n, (<=) n ((+) m 1)) => Diag (L m n) (R n)

Methods

takeDiag :: L m n -> R n

(KnownNat m, KnownNat n, (<=) m ((+) n 1)) => Diag (L m n) (R m)

Methods

takeDiag :: L m n -> R m

KnownNat n => Diag (L n n) (R n)

Methods

takeDiag :: L n n -> R n

data Sym n

Instances

KnownNat n => Show (Sym n)

Methods

showsPrec :: Int -> Sym n -> ShowS

show :: Sym n -> String

showList :: [Sym n] -> ShowS

KnownNat n => Eigen (Sym n) (R n) (L n n)

Methods

eigensystem :: Sym n -> (R n, L n n)

eigenvalues :: Sym n -> R n

sym :: KnownNat n => Sq n -> Sym n

mTm :: (KnownNat m, KnownNat n) => L m n -> Sym n

unSym :: Sym n -> Sq n

<·> :: R n -> R n -> ℝ infixr 8

Orphan instances

(KnownNat n', KnownNat m') => Testable (L n' m')

Methods

checkT :: L n' m' -> (Bool, IO ())

ioCheckT :: L n' m' -> IO (Bool, IO ())