-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/

-- | Numeric Linear Algebra
--   
--   Linear systems, matrix decompositions, and other numerical
--   computations based on BLAS and LAPACK.
--   
--   Standard interface: Numeric.LinearAlgebra.
--   
--   Safer interface with statically checked dimensions:
--   Numeric.LinearAlgebra.Static.
--   
--   Code examples: http://dis.um.es/~alberto/hmatrix/hmatrix.html
@package hmatrix
@version 0.20.2

-- | The library can be easily extended using the tools in this module.
module Numeric.LinearAlgebra.Devel
createVector :: Storable a => Int -> IO (Vector a)
createMatrix :: Storable a => MatrixOrder -> Int -> Int -> IO (Matrix a)
class TransArray c where {
    type Trans c b;
    type TransRaw c b;
}
apply :: TransArray c => c -> (b -> IO r) -> Trans c b -> IO r
applyRaw :: TransArray c => c -> (b -> IO r) -> TransRaw c b -> IO r
infixl 1 `apply`
infixl 1 `applyRaw`
data MatrixOrder
RowMajor :: MatrixOrder
ColumnMajor :: MatrixOrder
orderOf :: Matrix t -> MatrixOrder
cmat :: Element t => Matrix t -> Matrix t
fmat :: Element t => Matrix t -> Matrix t
matrixFromVector :: Storable t => MatrixOrder -> Int -> Int -> Vector t -> Matrix t
unsafeFromForeignPtr :: Storable a => ForeignPtr a -> Int -> Int -> Vector a
unsafeToForeignPtr :: Vector a -> (ForeignPtr a, Int, Int)

-- | check the error code
check :: String -> IO CInt -> IO ()

-- | postfix function application (flip ($))
(//) :: x -> (x -> y) -> y
infixl 0 //

-- | postfix error code check
(#|) :: IO CInt -> String -> IO ()
infixl 0 #|

-- | access to Vector elements without range checking
at' :: Storable a => Vector a -> Int -> a
atM' :: Storable t => Matrix t -> Int -> Int -> t

-- | specialized fromIntegral
fi :: Int -> CInt

-- | specialized fromIntegral
ti :: CInt -> Int
data STVector s t
newVector :: Storable t => t -> Int -> ST s (STVector s t)
thawVector :: Storable t => Vector t -> ST s (STVector s t)
freezeVector :: Storable t => STVector s t -> ST s (Vector t)
runSTVector :: Storable t => (forall s. () => ST s (STVector s t)) -> Vector t
readVector :: Storable t => STVector s t -> Int -> ST s t
writeVector :: Storable t => STVector s t -> Int -> t -> ST s ()
modifyVector :: Storable t => STVector s t -> Int -> (t -> t) -> ST s ()
liftSTVector :: Storable t => (Vector t -> a) -> STVector s t -> ST s a
data STMatrix s t
newMatrix :: Storable t => t -> Int -> Int -> ST s (STMatrix s t)
thawMatrix :: Element t => Matrix t -> ST s (STMatrix s t)
freezeMatrix :: Element t => STMatrix s t -> ST s (Matrix t)
runSTMatrix :: Storable t => (forall s. () => ST s (STMatrix s t)) -> Matrix t
readMatrix :: Storable t => STMatrix s t -> Int -> Int -> ST s t
writeMatrix :: Storable t => STMatrix s t -> Int -> Int -> t -> ST s ()
modifyMatrix :: Storable t => STMatrix s t -> Int -> Int -> (t -> t) -> ST s ()
liftSTMatrix :: Element t => (Matrix t -> a) -> STMatrix s t -> ST s a
mutable :: Element t => (forall s. () => (Int, Int) -> STMatrix s t -> ST s u) -> Matrix t -> (Matrix t, u)
extractMatrix :: Element a => STMatrix t a -> RowRange -> ColRange -> ST s (Matrix a)
setMatrix :: Element t => STMatrix s t -> Int -> Int -> Matrix t -> ST s ()
rowOper :: (Num t, Element t) => RowOper t -> STMatrix s t -> ST s ()
data RowOper t
AXPY :: t -> Int -> Int -> ColRange -> RowOper t
SCAL :: t -> RowRange -> ColRange -> RowOper t
SWAP :: Int -> Int -> ColRange -> RowOper t
data RowRange
AllRows :: RowRange
RowRange :: Int -> Int -> RowRange
Row :: Int -> RowRange
FromRow :: Int -> RowRange
data ColRange
AllCols :: ColRange
ColRange :: Int -> Int -> ColRange
Col :: Int -> ColRange
FromCol :: Int -> ColRange
gemmm :: Element t => t -> Slice s t -> t -> Slice s t -> Slice s t -> ST s ()

-- | r0 c0 height width
data Slice s t
Slice :: STMatrix s t -> Int -> Int -> Int -> Int -> Slice s t
newUndefinedVector :: Storable t => Int -> ST s (STVector s t)
unsafeReadVector :: Storable t => STVector s t -> Int -> ST s t
unsafeWriteVector :: Storable t => STVector s t -> Int -> t -> ST s ()
unsafeThawVector :: Storable t => Vector t -> ST s (STVector s t)
unsafeFreezeVector :: Storable t => STVector s t -> ST s (Vector t)
newUndefinedMatrix :: Storable t => MatrixOrder -> Int -> Int -> ST s (STMatrix s t)
unsafeReadMatrix :: Storable t => STMatrix s t -> Int -> Int -> ST s t
unsafeWriteMatrix :: Storable t => STMatrix s t -> Int -> Int -> t -> ST s ()
unsafeThawMatrix :: Storable t => Matrix t -> ST s (STMatrix s t)
unsafeFreezeMatrix :: Storable t => STMatrix s t -> ST s (Matrix t)
mapVectorWithIndex :: (Storable a, Storable b) => (Int -> a -> b) -> Vector a -> Vector b

-- | zip for Vectors
zipVector :: (Storable a, Storable b, Storable (a, b)) => Vector a -> Vector b -> Vector (a, b)

-- | zipWith for Vectors
zipVectorWith :: (Storable a, Storable b, Storable c) => (a -> b -> c) -> Vector a -> Vector b -> Vector c

-- | unzip for Vectors
unzipVector :: (Storable a, Storable b, Storable (a, b)) => Vector (a, b) -> (Vector a, Vector b)

-- | unzipWith for Vectors
unzipVectorWith :: (Storable (a, b), Storable c, Storable d) => ((a, b) -> (c, d)) -> Vector (a, b) -> (Vector c, Vector d)

-- | monadic map over Vectors the monad m must be strict
mapVectorM :: (Storable a, Storable b, Monad m) => (a -> m b) -> Vector a -> m (Vector b)

-- | monadic map over Vectors
mapVectorM_ :: (Storable a, Monad m) => (a -> m ()) -> Vector a -> m ()

-- | monadic map over Vectors with the zero-indexed index passed to the
--   mapping function the monad m must be strict
mapVectorWithIndexM :: (Storable a, Storable b, Monad m) => (Int -> a -> m b) -> Vector a -> m (Vector b)

-- | monadic map over Vectors with the zero-indexed index passed to the
--   mapping function
mapVectorWithIndexM_ :: (Storable a, Monad m) => (Int -> a -> m ()) -> Vector a -> m ()
foldLoop :: (Int -> t -> t) -> t -> Int -> t
foldVector :: Storable a => (a -> b -> b) -> b -> Vector a -> b
foldVectorG :: Storable t1 => (Int -> (Int -> t1) -> t -> t) -> t -> Vector t1 -> t
foldVectorWithIndex :: Storable a => (Int -> a -> b -> b) -> b -> Vector a -> b

-- | 
--   >>> mapMatrixWithIndex (\(i,j) v -> 100*v + 10*fromIntegral i + fromIntegral j) (ident 3:: Matrix Double)
--   (3><3)
--    [ 100.0,   1.0,   2.0
--    ,  10.0, 111.0,  12.0
--    ,  20.0,  21.0, 122.0 ]
--   
mapMatrixWithIndex :: (Element a, Storable b) => ((Int, Int) -> a -> b) -> Matrix a -> Matrix b

-- | 
--   >>> mapMatrixWithIndexM (\(i,j) v -> Just $ 100*v + 10*fromIntegral i + fromIntegral j) (ident 3:: Matrix Double)
--   Just (3><3)
--    [ 100.0,   1.0,   2.0
--    ,  10.0, 111.0,  12.0
--    ,  20.0,  21.0, 122.0 ]
--   
mapMatrixWithIndexM :: (Element a, Storable b, Monad m) => ((Int, Int) -> a -> m b) -> Matrix a -> m (Matrix b)

-- | 
--   >>> mapMatrixWithIndexM_ (\(i,j) v -> printf "m[%d,%d] = %.f\n" i j v :: IO()) ((2><3)[1 :: Double ..])
--   m[0,0] = 1
--   m[0,1] = 2
--   m[0,2] = 3
--   m[1,0] = 4
--   m[1,1] = 5
--   m[1,2] = 6
--   
mapMatrixWithIndexM_ :: (Element a, Num a, Monad m) => ((Int, Int) -> a -> m ()) -> Matrix a -> m ()

-- | application of a vector function on the flattened matrix elements
liftMatrix :: (Element a, Element b) => (Vector a -> Vector b) -> Matrix a -> Matrix b

-- | application of a vector function on the flattened matrices elements
liftMatrix2 :: (Element t, Element a, Element b) => (Vector a -> Vector b -> Vector t) -> Matrix a -> Matrix b -> Matrix t

-- | A version of liftMatrix2 which automatically adapt matrices
--   with a single row or column to match the dimensions of the other
--   matrix.
liftMatrix2Auto :: (Element t, Element a, Element b) => (Vector a -> Vector b -> Vector t) -> Matrix a -> Matrix b -> Matrix t
data CSR
CSR :: Vector Double -> Vector CInt -> Vector CInt -> Int -> Int -> CSR
[csrVals] :: CSR -> Vector Double
[csrCols] :: CSR -> Vector CInt
[csrRows] :: CSR -> Vector CInt
[csrNRows] :: CSR -> Int
[csrNCols] :: CSR -> Int
fromCSR :: CSR -> GMatrix

-- | Produce a CSR sparse matrix from a association matrix.
mkCSR :: AssocMatrix -> CSR

-- | Produce a CSR sparse matrix by applying a generic folding function.
--   
--   This allows one to build a CSR from an effectful streaming source when
--   combined with libraries like pipes, io-streams, or streaming.
--   
--   For example
--   
--   
--   impureCSR Pipes.Prelude.foldM :: PrimMonad m => Producer AssocEntry m () -> m CSR
--   impureCSR Streaming.Prelude.foldM :: PrimMonad m => Stream (Of AssocEntry) m r -> m (Of CSR r)
--   
impureCSR :: PrimMonad m => (forall x. () => (x -> (IndexOf Matrix, Double) -> m x) -> m x -> (x -> m CSR) -> r) -> r

-- | General matrix with specialized internal representations for dense,
--   sparse, diagonal, banded, and constant elements.
--   
--   
--   >>> let m = mkSparse [((0,999),1.0),((1,1999),2.0)]
--   
--   >>> m
--   SparseR {gmCSR = CSR {csrVals = fromList [1.0,2.0],
--                         csrCols = fromList [1000,2000],
--                         csrRows = fromList [1,2,3],
--                         csrNRows = 2,
--                         csrNCols = 2000},
--                         nRows = 2,
--                         nCols = 2000}
--   
--   
--   
--   >>> let m = mkDense (mat 2 [1..4])
--   
--   >>> m
--   Dense {gmDense = (2><2)
--    [ 1.0, 2.0
--    , 3.0, 4.0 ], nRows = 2, nCols = 2}
--   
data GMatrix
SparseR :: CSR -> Int -> Int -> GMatrix
[gmCSR] :: GMatrix -> CSR
[nRows] :: GMatrix -> Int
[nCols] :: GMatrix -> Int
SparseC :: CSC -> Int -> Int -> GMatrix
[gmCSC] :: GMatrix -> CSC
[nRows] :: GMatrix -> Int
[nCols] :: GMatrix -> Int
Diag :: Vector Double -> Int -> Int -> GMatrix
[diagVals] :: GMatrix -> Vector Double
[nRows] :: GMatrix -> Int
[nCols] :: GMatrix -> Int
Dense :: Matrix Double -> Int -> Int -> GMatrix
[gmDense] :: GMatrix -> Matrix Double
[nRows] :: GMatrix -> Int
[nCols] :: GMatrix -> Int
toByteString :: Storable t => Vector t -> ByteString
fromByteString :: Storable t => ByteString -> Vector t
showInternal :: Storable t => Matrix t -> IO ()

-- | Transpose an array with dimensions dims by making a copy
--   using strides. For example, for an array with 3 indices,
--   (reorderVector strides dims v) ! ((i * dims ! 1 + j) * dims ! 2 +
--   k) == v ! (i * strides ! 0 + j * strides ! 1 + k * strides ! 2)
--   This function is intended to be used internally by tensor libraries.
reorderVector :: Element a => Vector CInt -> Vector CInt -> Vector a -> Vector a

-- | This module provides functions for creation and manipulation of
--   vectors and matrices, IO, and other utilities.
module Numeric.LinearAlgebra.Data
type R = Double
type C = Complex Double
type I = CInt
type Z = Int64
type x ./. (n :: Nat) = Mod n x
infixr 5 ./.
fromList :: Storable a => [a] -> Vector a
toList :: Storable a => Vector a -> [a]

-- | Create a vector from a list of elements and explicit dimension. The
--   input list is truncated if it is too long, so it may safely be used,
--   for instance, with infinite lists.
--   
--   
--   >>> 5 |> [1..]
--   [1.0,2.0,3.0,4.0,5.0]
--   it :: (Enum a, Num a, Foreign.Storable.Storable a) => Vector a
--   
(|>) :: Storable a => Int -> [a] -> Vector a
infixl 9 |>

-- | Create a real vector.
--   
--   
--   >>> vector [1..5]
--   [1.0,2.0,3.0,4.0,5.0]
--   it :: Vector R
--   
vector :: [R] -> Vector R

-- | 
--   >>> range 5
--   [0,1,2,3,4]
--   it :: Vector I
--   
range :: Int -> Vector I

-- | Create a vector of indexes, useful for matrix extraction using
--   (??)
idxs :: [Int] -> Vector I

-- | Create a matrix from a list of elements
--   
--   
--   >>> (2><3) [2, 4, 7+2*iC,   -3, 11, 0]
--   (2><3)
--    [       2.0 :+ 0.0,  4.0 :+ 0.0, 7.0 :+ 2.0
--    , (-3.0) :+ (-0.0), 11.0 :+ 0.0, 0.0 :+ 0.0 ]
--   
--   
--   The input list is explicitly truncated, so that it can safely be used
--   with lists that are too long (like infinite lists).
--   
--   
--   >>> (2><3)[1..]
--   (2><3)
--    [ 1.0, 2.0, 3.0
--    , 4.0, 5.0, 6.0 ]
--   
--   
--   This is the format produced by the instances of Show (Matrix a), which
--   can also be used for input.
(><) :: Storable a => Int -> Int -> [a] -> Matrix a

-- | Create a real matrix.
--   
--   
--   >>> matrix 5 [1..15]
--   (3><5)
--    [  1.0,  2.0,  3.0,  4.0,  5.0
--    ,  6.0,  7.0,  8.0,  9.0, 10.0
--    , 11.0, 12.0, 13.0, 14.0, 15.0 ]
--   
matrix :: Int -> [R] -> Matrix R

-- | conjugate transpose
tr :: Transposable m mt => m -> mt

-- | transpose
tr' :: Transposable m mt => m -> mt

-- | 
--   >>> size $ vector [1..10]
--   10
--   
--   >>> size $ (2><5)[1..10::Double]
--   (2,5)
--   
size :: Container c t => c t -> IndexOf c
rows :: Matrix t -> Int
cols :: Matrix t -> Int

-- | Creates a Matrix from a list of lists (considered as rows).
--   
--   
--   >>> fromLists [[1,2],[3,4],[5,6]]
--   (3><2)
--    [ 1.0, 2.0
--    , 3.0, 4.0
--    , 5.0, 6.0 ]
--   
fromLists :: Element t => [[t]] -> Matrix t

-- | the inverse of fromLists
toLists :: Element t => Matrix t -> [[t]]

-- | create a single row real matrix from a list
--   
--   
--   >>> row [2,3,1,8]
--   (1><4)
--    [ 2.0, 3.0, 1.0, 8.0 ]
--   
row :: [Double] -> Matrix Double

-- | create a single column real matrix from a list
--   
--   
--   >>> col [7,-2,4]
--   (3><1)
--    [  7.0
--    , -2.0
--    ,  4.0 ]
--   
col :: [Double] -> Matrix Double

-- | Creates a vector by concatenation of rows. If the matrix is
--   ColumnMajor, this operation requires a transpose.
--   
--   
--   >>> flatten (ident 3)
--   [1.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,1.0]
--   it :: (Num t, Element t) => Vector t
--   
flatten :: Element t => Matrix t -> Vector t

-- | Creates a matrix from a vector by grouping the elements in rows with
--   the desired number of columns. (GNU-Octave groups by columns. To do it
--   you can define reshapeF r = tr' . reshape r where r is the
--   desired number of rows.)
--   
--   
--   >>> reshape 4 (fromList [1..12])
--   (3><4)
--    [ 1.0,  2.0,  3.0,  4.0
--    , 5.0,  6.0,  7.0,  8.0
--    , 9.0, 10.0, 11.0, 12.0 ]
--   
reshape :: Storable t => Int -> Vector t -> Matrix t

-- | creates a 1-row matrix from a vector
--   
--   
--   >>> asRow (fromList [1..5])
--    (1><5)
--     [ 1.0, 2.0, 3.0, 4.0, 5.0 ]
--   
asRow :: Storable a => Vector a -> Matrix a

-- | creates a 1-column matrix from a vector
--   
--   
--   >>> asColumn (fromList [1..5])
--   (5><1)
--    [ 1.0
--    , 2.0
--    , 3.0
--    , 4.0
--    , 5.0 ]
--   
asColumn :: Storable a => Vector a -> Matrix a

-- | Create a matrix from a list of vectors. All vectors must have the same
--   dimension, or dimension 1, which is are automatically expanded.
fromRows :: Element t => [Vector t] -> Matrix t

-- | extracts the rows of a matrix as a list of vectors
toRows :: Element t => Matrix t -> [Vector t]

-- | Creates a matrix from a list of vectors, as columns
fromColumns :: Element t => [Vector t] -> Matrix t

-- | Creates a list of vectors from the columns of a matrix
toColumns :: Element t => Matrix t -> [Vector t]

-- | generic indexing function
--   
--   
--   >>> vector [1,2,3] `atIndex` 1
--   2.0
--   
--   
--   
--   >>> matrix 3 [0..8] `atIndex` (2,0)
--   6.0
--   
atIndex :: Container c e => c e -> IndexOf c -> e

-- | Alternative indexing function.
--   
--   
--   >>> vector [1..10] ! 3
--   4.0
--   
--   
--   On a matrix it gets the k-th row as a vector:
--   
--   
--   >>> matrix 5 [1..15] ! 1
--   [6.0,7.0,8.0,9.0,10.0]
--   it :: Vector Double
--   
--   
--   
--   >>> matrix 5 [1..15] ! 1 ! 3
--   9.0
--   
class Indexable c t | c -> t, t -> c
(!) :: Indexable c t => c -> Int -> t
infixl 9 !

-- | create a structure with a single element
--   
--   
--   >>> let v = fromList [1..3::Double]
--   
--   >>> v / scalar (norm2 v)
--   fromList [0.2672612419124244,0.5345224838248488,0.8017837257372732]
--   
scalar :: Container c e => e -> c e
class Konst e d (c :: Type -> Type) | d -> c, c -> d

-- | 
--   >>> konst 7 3 :: Vector Float
--   fromList [7.0,7.0,7.0]
--   
--   
--   
--   >>> konst i (3::Int,4::Int)
--   (3><4)
--    [ 0.0 :+ 1.0, 0.0 :+ 1.0, 0.0 :+ 1.0, 0.0 :+ 1.0
--    , 0.0 :+ 1.0, 0.0 :+ 1.0, 0.0 :+ 1.0, 0.0 :+ 1.0
--    , 0.0 :+ 1.0, 0.0 :+ 1.0, 0.0 :+ 1.0, 0.0 :+ 1.0 ]
--   
konst :: Konst e d c => e -> d -> c e
class Build d f (c :: Type -> Type) e | d -> c, c -> d, f -> e, f -> d, f -> c, c e -> f, d e -> f

-- | 
--   >>> build 5 (**2) :: Vector Double
--   [0.0,1.0,4.0,9.0,16.0]
--   it :: Vector Double
--   
--   
--   Hilbert matrix of order N:
--   
--   
--   >>> let hilb n = build (n,n) (\i j -> 1/(i+j+1)) :: Matrix Double
--   
--   >>> putStr . dispf 2 $ hilb 3
--   3x3
--   1.00  0.50  0.33
--   0.50  0.33  0.25
--   0.33  0.25  0.20
--   
build :: Build d f c e => d -> f -> c e

-- | Create a structure from an association list
--   
--   
--   >>> assoc 5 0 [(3,7),(1,4)] :: Vector Double
--   fromList [0.0,4.0,0.0,7.0,0.0]
--   
--   
--   
--   >>> assoc (2,3) 0 [((0,2),7),((1,0),2*i-3)] :: Matrix (Complex Double)
--   (2><3)
--    [    0.0 :+ 0.0, 0.0 :+ 0.0, 7.0 :+ 0.0
--    , (-3.0) :+ 2.0, 0.0 :+ 0.0, 0.0 :+ 0.0 ]
--   
assoc :: Container c e => IndexOf c -> e -> [(IndexOf c, e)] -> c e

-- | Modify a structure using an update function
--   
--   
--   >>> accum (ident 5) (+) [((1,1),5),((0,3),3)] :: Matrix Double
--   (5><5)
--    [ 1.0, 0.0, 0.0, 3.0, 0.0
--    , 0.0, 6.0, 0.0, 0.0, 0.0
--    , 0.0, 0.0, 1.0, 0.0, 0.0
--    , 0.0, 0.0, 0.0, 1.0, 0.0
--    , 0.0, 0.0, 0.0, 0.0, 1.0 ]
--   
--   
--   computation of histogram:
--   
--   
--   >>> accum (konst 0 7) (+) (map (flip (,) 1) [4,5,4,1,5,2,5]) :: Vector Double
--   fromList [0.0,1.0,1.0,0.0,2.0,3.0,0.0]
--   
accum :: Container c e => c e -> (e -> e -> e) -> [(IndexOf c, e)] -> c e

-- | Creates a real vector containing a range of values:
--   
--   
--   >>> linspace 5 (-3,7::Double)
--   [-3.0,-0.5,2.0,4.5,7.0]
--   it :: Vector Double
--   
--   
--   
--   >>> linspace 5 (8,3:+2) :: Vector (Complex Double)
--   [8.0 :+ 0.0,6.75 :+ 0.5,5.5 :+ 1.0,4.25 :+ 1.5,3.0 :+ 2.0]
--   it :: Vector (Complex Double)
--   
--   
--   Logarithmic spacing can be defined as follows:
--   
--   
--   logspace n (a,b) = 10 ** linspace n (a,b)
--   
linspace :: (Fractional e, Container Vector e) => Int -> (e, e) -> Vector e

-- | creates the identity matrix of given dimension
ident :: (Num a, Element a) => Int -> Matrix a

-- | Creates a square matrix with a given diagonal.
diag :: (Num a, Element a) => Vector a -> Matrix a

-- | create a real diagonal matrix from a list
--   
--   
--   >>> diagl [1,2,3]
--   (3><3)
--    [ 1.0, 0.0, 0.0
--    , 0.0, 2.0, 0.0
--    , 0.0, 0.0, 3.0 ]
--   
diagl :: [Double] -> Matrix Double

-- | creates a rectangular diagonal matrix:
--   
--   
--   >>> diagRect 7 (fromList [10,20,30]) 4 5 :: Matrix Double
--   (4><5)
--    [ 10.0,  7.0,  7.0, 7.0, 7.0
--    ,  7.0, 20.0,  7.0, 7.0, 7.0
--    ,  7.0,  7.0, 30.0, 7.0, 7.0
--    ,  7.0,  7.0,  7.0, 7.0, 7.0 ]
--   
diagRect :: Storable t => t -> Vector t -> Int -> Int -> Matrix t

-- | extracts the diagonal from a rectangular matrix
takeDiag :: Element t => Matrix t -> Vector t

-- | takes a number of consecutive elements from a Vector
--   
--   
--   >>> subVector 2 3 (fromList [1..10])
--   [3.0,4.0,5.0]
--   it :: (Enum t, Num t, Foreign.Storable.Storable t) => Vector t
--   
subVector :: Storable t => Int -> Int -> Vector t -> Vector t

-- | Extract consecutive subvectors of the given sizes.
--   
--   
--   >>> takesV [3,4] (linspace 10 (1,10::Double))
--   [[1.0,2.0,3.0],[4.0,5.0,6.0,7.0]]
--   it :: [Vector Double]
--   
takesV :: Storable t => [Int] -> Vector t -> [Vector t]

-- | concatenate a list of vectors
--   
--   
--   >>> vjoin [fromList [1..5::Double], konst 1 3]
--   [1.0,2.0,3.0,4.0,5.0,1.0,1.0,1.0]
--   it :: Vector Double
--   
vjoin :: Storable t => [Vector t] -> Vector t

-- | Specification of indexes for the operator ??.
data Extractor
All :: Extractor
Range :: Int -> Int -> Int -> Extractor
Pos :: Vector I -> Extractor
PosCyc :: Vector I -> Extractor
Take :: Int -> Extractor
TakeLast :: Int -> Extractor
Drop :: Int -> Extractor
DropLast :: Int -> Extractor

-- | General matrix slicing.
--   
--   
--   >>> m
--   (4><5)
--    [  0,  1,  2,  3,  4
--    ,  5,  6,  7,  8,  9
--    , 10, 11, 12, 13, 14
--    , 15, 16, 17, 18, 19 ]
--   
--   
--   
--   >>> m ?? (Take 3, DropLast 2)
--   (3><3)
--    [  0,  1,  2
--    ,  5,  6,  7
--    , 10, 11, 12 ]
--   
--   
--   
--   >>> m ?? (Pos (idxs[2,1]), All)
--   (2><5)
--    [ 10, 11, 12, 13, 14
--    ,  5,  6,  7,  8,  9 ]
--   
--   
--   
--   >>> m ?? (PosCyc (idxs[-7,80]), Range 4 (-2) 0)
--   (2><3)
--    [ 9, 7, 5
--    , 4, 2, 0 ]
--   
(??) :: Element t => Matrix t -> (Extractor, Extractor) -> Matrix t
infixl 9 ??

-- | extract rows
--   
--   
--   >>> (20><4) [1..] ? [2,1,1]
--   (3><4)
--    [ 9.0, 10.0, 11.0, 12.0
--    , 5.0,  6.0,  7.0,  8.0
--    , 5.0,  6.0,  7.0,  8.0 ]
--   
(?) :: Element t => Matrix t -> [Int] -> Matrix t
infixl 9 ?

-- | extract columns
--   
--   (unicode 0x00bf, inverted question mark, Alt-Gr ?)
--   
--   
--   >>> (3><4) [1..] ¿ [3,0]
--   (3><2)
--    [  4.0, 1.0
--    ,  8.0, 5.0
--    , 12.0, 9.0 ]
--   
(¿) :: Element t => Matrix t -> [Int] -> Matrix t
infixl 9 ¿

-- | Reverse columns
fliprl :: Element t => Matrix t -> Matrix t

-- | Reverse rows
flipud :: Element t => Matrix t -> Matrix t

-- | reference to a rectangular slice of a matrix (no data copy)
subMatrix :: Element a => (Int, Int) -> (Int, Int) -> Matrix a -> Matrix a
takeRows :: Element t => Int -> Matrix t -> Matrix t
dropRows :: Element t => Int -> Matrix t -> Matrix t
takeColumns :: Element t => Int -> Matrix t -> Matrix t
dropColumns :: Element t => Int -> Matrix t -> Matrix t

-- | Extract elements from positions given in matrices of rows and columns.
--   
--   
--   >>> r
--   (3><3)
--    [ 1, 1, 1
--    , 1, 2, 2
--    , 1, 2, 3 ]
--   
--   >>> c
--   (3><3)
--    [ 0, 1, 5
--    , 2, 2, 1
--    , 4, 4, 1 ]
--   
--   >>> m
--   (4><6)
--    [  0,  1,  2,  3,  4,  5
--    ,  6,  7,  8,  9, 10, 11
--    , 12, 13, 14, 15, 16, 17
--    , 18, 19, 20, 21, 22, 23 ]
--   
--   
--   
--   >>> remap r c m
--   (3><3)
--    [  6,  7, 11
--    ,  8, 14, 13
--    , 10, 16, 19 ]
--   
--   
--   The indexes are autoconformable.
--   
--   
--   >>> c'
--   (3><1)
--    [ 1
--    , 2
--    , 4 ]
--   
--   >>> remap r c' m
--   (3><3)
--    [  7,  7,  7
--    ,  8, 14, 14
--    , 10, 16, 22 ]
--   
remap :: Element t => Matrix I -> Matrix I -> Matrix t -> Matrix t

-- | Create a matrix from blocks given as a list of lists of matrices.
--   
--   Single row-column components are automatically expanded to match the
--   corresponding common row and column:
--   
--   
--   disp = putStr . dispf 2
--   
--   
--   
--   >>> disp $ fromBlocks [[ident 5, 7, row[10,20]], [3, diagl[1,2,3], 0]]
--   8x10
--   1  0  0  0  0  7  7  7  10  20
--   0  1  0  0  0  7  7  7  10  20
--   0  0  1  0  0  7  7  7  10  20
--   0  0  0  1  0  7  7  7  10  20
--   0  0  0  0  1  7  7  7  10  20
--   3  3  3  3  3  1  0  0   0   0
--   3  3  3  3  3  0  2  0   0   0
--   3  3  3  3  3  0  0  3   0   0
--   
fromBlocks :: Element t => [[Matrix t]] -> Matrix t

-- | horizontal concatenation
--   
--   
--   >>> ident 3 ||| konst 7 (3,4)
--   (3><7)
--    [ 1.0, 0.0, 0.0, 7.0, 7.0, 7.0, 7.0
--    , 0.0, 1.0, 0.0, 7.0, 7.0, 7.0, 7.0
--    , 0.0, 0.0, 1.0, 7.0, 7.0, 7.0, 7.0 ]
--   
(|||) :: Element t => Matrix t -> Matrix t -> Matrix t
infixl 3 |||

-- | vertical concatenation
(===) :: Element t => Matrix t -> Matrix t -> Matrix t
infixl 2 ===

-- | create a block diagonal matrix
--   
--   
--   >>> disp 2 $ diagBlock [konst 1 (2,2), konst 2 (3,5), col [5,7]]
--   7x8
--   1  1  0  0  0  0  0  0
--   1  1  0  0  0  0  0  0
--   0  0  2  2  2  2  2  0
--   0  0  2  2  2  2  2  0
--   0  0  2  2  2  2  2  0
--   0  0  0  0  0  0  0  5
--   0  0  0  0  0  0  0  7
--   
--   
--   
--   >>> diagBlock [(0><4)[], konst 2 (2,3)]  :: Matrix Double
--   (2><7)
--    [ 0.0, 0.0, 0.0, 0.0, 2.0, 2.0, 2.0
--    , 0.0, 0.0, 0.0, 0.0, 2.0, 2.0, 2.0 ]
--   
diagBlock :: (Element t, Num t) => [Matrix t] -> Matrix t

-- | creates matrix by repetition of a matrix a given number of rows and
--   columns
--   
--   
--   >>> repmat (ident 2) 2 3
--   (4><6)
--    [ 1.0, 0.0, 1.0, 0.0, 1.0, 0.0
--    , 0.0, 1.0, 0.0, 1.0, 0.0, 1.0
--    , 1.0, 0.0, 1.0, 0.0, 1.0, 0.0
--    , 0.0, 1.0, 0.0, 1.0, 0.0, 1.0 ]
--   
repmat :: Element t => Matrix t -> Int -> Int -> Matrix t

-- | Partition a matrix into blocks with the given numbers of rows and
--   columns. The remaining rows and columns are discarded.
toBlocks :: Element t => [Int] -> [Int] -> Matrix t -> [[Matrix t]]

-- | Fully partition a matrix into blocks of the same size. If the
--   dimensions are not a multiple of the given size the last blocks will
--   be smaller.
toBlocksEvery :: Element t => Int -> Int -> Matrix t -> [[Matrix t]]

-- | complex conjugate
conj :: Container c e => c e -> c e

-- | like fmap (cannot implement instance Functor because of Element
--   class constraint)
cmap :: (Element b, Container c e) => (e -> b) -> c e -> c b

-- | mod for integer arrays
--   
--   
--   >>> cmod 3 (range 5)
--   fromList [0,1,2,0,1]
--   
cmod :: (Integral e, Container c e) => e -> c e -> c e

-- | A more efficient implementation of cmap (\x -> if x>0 then 1
--   else 0)
--   
--   
--   >>> step $ linspace 5 (-1,1::Double)
--   5 |> [0.0,0.0,0.0,1.0,1.0]
--   
step :: (Ord e, Container c e) => c e -> c e

-- | Element by element version of case compare a b of {LT -> l; EQ
--   -> e; GT -> g}.
--   
--   Arguments with any dimension = 1 are automatically expanded:
--   
--   
--   >>> cond ((1><4)[1..]) ((3><1)[1..]) 0 100 ((3><4)[1..]) :: Matrix Double
--   (3><4)
--   [ 100.0,   2.0,   3.0,  4.0
--   ,   0.0, 100.0,   7.0,  8.0
--   ,   0.0,   0.0, 100.0, 12.0 ]
--   
--   
--   
--   >>> let chop x = cond (abs x) 1E-6 0 0 x
--   
cond :: (Ord e, Container c e, Container c x) => c e -> c e -> c x -> c x -> c x -> c x

-- | Find index of elements which satisfy a predicate
--   
--   
--   >>> find (>0) (ident 3 :: Matrix Double)
--   [(0,0),(1,1),(2,2)]
--   
find :: Container c e => (e -> Bool) -> c e -> [IndexOf c]

-- | index of maximum element
maxIndex :: Container c e => c e -> IndexOf c

-- | index of minimum element
minIndex :: Container c e => c e -> IndexOf c

-- | value of maximum element
maxElement :: Container c e => c e -> e

-- | value of minimum element
minElement :: Container c e => c e -> e
sortVector :: (Ord t, Element t) => Vector t -> Vector t

-- | 
--   >>> m <- randn 4 10
--   
--   >>> disp 2 m
--   4x10
--   -0.31   0.41   0.43  -0.19  -0.17  -0.23  -0.17  -1.04  -0.07  -1.24
--    0.26   0.19   0.14   0.83  -1.54  -0.09   0.37  -0.63   0.71  -0.50
--   -0.11  -0.10  -1.29  -1.40  -1.04  -0.89  -0.68   0.35  -1.46   1.86
--    1.04  -0.29   0.19  -0.75  -2.20  -0.01   1.06   0.11  -2.09  -1.58
--   
--   
--   
--   >>> disp 2 $ m ?? (All, Pos $ sortIndex (m!1))
--   4x10
--   -0.17  -1.04  -1.24  -0.23   0.43   0.41  -0.31  -0.17  -0.07  -0.19
--   -1.54  -0.63  -0.50  -0.09   0.14   0.19   0.26   0.37   0.71   0.83
--   -1.04   0.35   1.86  -0.89  -1.29  -0.10  -0.11  -0.68  -1.46  -1.40
--   -2.20   0.11  -1.58  -0.01   0.19  -0.29   1.04   1.06  -2.09  -0.75
--   
sortIndex :: (Ord t, Element t) => Vector t -> Vector I
type AssocMatrix = [(IndexOf Matrix, Double)]
toDense :: AssocMatrix -> Matrix Double
mkSparse :: AssocMatrix -> GMatrix
mkDiagR :: Int -> Int -> Vector Double -> GMatrix
mkDense :: Matrix Double -> GMatrix

-- | print a real matrix with given number of digits after the decimal
--   point
--   
--   
--   >>> disp 5 $ ident 2 / 3
--   2x2
--   0.33333  0.00000
--   0.00000  0.33333
--   
disp :: Int -> Matrix Double -> IO ()

-- | load a matrix from an ASCII file formatted as a 2D table.
loadMatrix :: FilePath -> IO (Matrix Double)
loadMatrix' :: FilePath -> IO (Maybe (Matrix Double))

-- | save a matrix as a 2D ASCII table
saveMatrix :: FilePath -> String -> Matrix Double -> IO ()

-- | Tool to display matrices with latex syntax.
--   
--   
--   >>> latexFormat "bmatrix" (dispf 2 $ ident 2)
--   "\\begin{bmatrix}\n1  &  0\n\\\\\n0  &  1\n\\end{bmatrix}"
--   
latexFormat :: String -> String -> String

-- | Show a matrix with a given number of decimal places.
--   
--   
--   >>> dispf 2 (1/3 + ident 3)
--   "3x3\n1.33  0.33  0.33\n0.33  1.33  0.33\n0.33  0.33  1.33\n"
--   
--   
--   
--   >>> putStr . dispf 2 $ (3><4)[1,1.5..]
--   3x4
--   1.00  1.50  2.00  2.50
--   3.00  3.50  4.00  4.50
--   5.00  5.50  6.00  6.50
--   
--   
--   
--   >>> putStr . unlines . tail . lines . dispf 2 . asRow $ linspace 10 (0,1)
--   0.00  0.11  0.22  0.33  0.44  0.56  0.67  0.78  0.89  1.00
--   
dispf :: Int -> Matrix Double -> String

-- | Show a matrix with "autoscaling" and a given number of decimal places.
--   
--   
--   >>> putStr . disps 2 $ 120 * (3><4) [1..]
--   3x4  E3
--    0.12  0.24  0.36  0.48
--    0.60  0.72  0.84  0.96
--    1.08  1.20  1.32  1.44
--   
disps :: Int -> Matrix Double -> String

-- | Pretty print a complex matrix with at most n decimal digits.
dispcf :: Int -> Matrix (Complex Double) -> String

-- | Creates a string from a matrix given a separator and a function to
--   show each entry. Using this function the user can easily define any
--   desired display function:
--   
--   
--   import Text.Printf(printf)
--   
--   
--   
--   disp = putStr . format "  " (printf "%.2f")
--   
format :: Element t => String -> (t -> String) -> Matrix t -> String
dispDots :: Int -> Matrix Double -> IO ()
dispBlanks :: Int -> Matrix Double -> IO ()
dispShort :: Int -> Int -> Int -> Matrix Double -> IO ()
class Convert t
real :: (Convert t, Complexable c) => c (RealOf t) -> c t
complex :: (Convert t, Complexable c) => c t -> c (ComplexOf t)
single :: (Convert t, Complexable c) => c t -> c (SingleOf t)
double :: (Convert t, Complexable c) => c t -> c (DoubleOf t)
toComplex :: (Convert t, Complexable c, RealElement t) => (c t, c t) -> c (Complex t)
fromComplex :: (Convert t, Complexable c, RealElement t) => c (Complex t) -> (c t, c t)
roundVector :: Vector Double -> Vector Double

-- | 
--   >>> fromInt ((2><2) [0..3]) :: Matrix (Complex Double)
--   (2><2)
--   [ 0.0 :+ 0.0, 1.0 :+ 0.0
--   , 2.0 :+ 0.0, 3.0 :+ 0.0 ]
--   
fromInt :: Container c e => c I -> c e
toInt :: Container c e => c e -> c I
fromZ :: Container c e => c Z -> c e
toZ :: Container c e => c e -> c Z
arctan2 :: (Fractional e, Container c e) => c e -> c e -> c e

-- | matrix computation implemented as separated vector operations by rows
--   and columns.
separable :: Element t => (Vector t -> Vector t) -> Matrix t -> Matrix t
fromArray2D :: Storable e => Array (Int, Int) e -> Matrix e

-- | Wrapper with a phantom integer for statically checked modular
--   arithmetic.
data Mod (n :: Nat) t
data Vector a

-- | Matrix representation suitable for BLAS/LAPACK computations.
data Matrix t

-- | General matrix with specialized internal representations for dense,
--   sparse, diagonal, banded, and constant elements.
--   
--   
--   >>> let m = mkSparse [((0,999),1.0),((1,1999),2.0)]
--   
--   >>> m
--   SparseR {gmCSR = CSR {csrVals = fromList [1.0,2.0],
--                         csrCols = fromList [1000,2000],
--                         csrRows = fromList [1,2,3],
--                         csrNRows = 2,
--                         csrNCols = 2000},
--                         nRows = 2,
--                         nCols = 2000}
--   
--   
--   
--   >>> let m = mkDense (mat 2 [1..4])
--   
--   >>> m
--   Dense {gmDense = (2><2)
--    [ 1.0, 2.0
--    , 3.0, 4.0 ], nRows = 2, nCols = 2}
--   
data GMatrix
nRows :: GMatrix -> Int
nCols :: GMatrix -> Int

module Numeric.LinearAlgebra
dot :: Numeric t => Vector t -> Vector t -> t

-- | An infix synonym for dot
--   
--   
--   >>> vector [1,2,3,4] <.> vector [-2,0,1,1]
--   5.0
--   
--   
--   
--   >>> let 𝑖 = 0:+1 :: C
--   
--   >>> fromList [1+𝑖,1] <.> fromList [1,1+𝑖]
--   2.0 :+ 0.0
--   
(<.>) :: Numeric t => Vector t -> Vector t -> t
infixr 8 <.>

-- | dense matrix-vector product
--   
--   
--   >>> let m = (2><3) [1..]
--   
--   >>> m
--   (2><3)
--    [ 1.0, 2.0, 3.0
--    , 4.0, 5.0, 6.0 ]
--   
--   
--   
--   >>> let v = vector [10,20,30]
--   
--   
--   
--   >>> m #> v
--   [140.0,320.0]
--   it :: Vector Numeric.LinearAlgebra.Data.R
--   
(#>) :: Numeric t => Matrix t -> Vector t -> Vector t
infixr 8 #>

-- | dense vector-matrix product
(<#) :: Numeric t => Vector t -> Matrix t -> Vector t
infixl 8 <#

-- | general matrix - vector product
--   
--   
--   >>> let m = mkSparse [((0,999),1.0),((1,1999),2.0)]
--   m :: GMatrix
--   
--   >>> m !#> vector [1..2000]
--   [1000.0,4000.0]
--   it :: Vector Double
--   
(!#>) :: GMatrix -> Vector Double -> Vector Double
infixr 8 !#>

-- | dense matrix product
--   
--   
--   >>> let a = (3><5) [1..]
--   
--   >>> a
--   (3><5)
--    [  1.0,  2.0,  3.0,  4.0,  5.0
--    ,  6.0,  7.0,  8.0,  9.0, 10.0
--    , 11.0, 12.0, 13.0, 14.0, 15.0 ]
--   
--   
--   
--   >>> let b = (5><2) [1,3, 0,2, -1,5, 7,7, 6,0]
--   
--   >>> b
--   (5><2)
--    [  1.0, 3.0
--    ,  0.0, 2.0
--    , -1.0, 5.0
--    ,  7.0, 7.0
--    ,  6.0, 0.0 ]
--   
--   
--   
--   >>> a <> b
--   (3><2)
--    [  56.0,  50.0
--    , 121.0, 135.0
--    , 186.0, 220.0 ]
--   
(<>) :: Numeric t => Matrix t -> Matrix t -> Matrix t
infixr 8 <>

-- | Outer product of two vectors.
--   
--   
--   >>> fromList [1,2,3] `outer` fromList [5,2,3]
--   (3><3)
--    [  5.0, 2.0, 3.0
--    , 10.0, 4.0, 6.0
--    , 15.0, 6.0, 9.0 ]
--   
outer :: Product t => Vector t -> Vector t -> Matrix t

-- | Kronecker product of two matrices.
--   
--   
--   m1=(2><3)
--    [ 1.0,  2.0, 0.0
--    , 0.0, -1.0, 3.0 ]
--   m2=(4><3)
--    [  1.0,  2.0,  3.0
--    ,  4.0,  5.0,  6.0
--    ,  7.0,  8.0,  9.0
--    , 10.0, 11.0, 12.0 ]
--   
--   
--   
--   >>> kronecker m1 m2
--   (8><9)
--    [  1.0,  2.0,  3.0,   2.0,   4.0,   6.0,  0.0,  0.0,  0.0
--    ,  4.0,  5.0,  6.0,   8.0,  10.0,  12.0,  0.0,  0.0,  0.0
--    ,  7.0,  8.0,  9.0,  14.0,  16.0,  18.0,  0.0,  0.0,  0.0
--    , 10.0, 11.0, 12.0,  20.0,  22.0,  24.0,  0.0,  0.0,  0.0
--    ,  0.0,  0.0,  0.0,  -1.0,  -2.0,  -3.0,  3.0,  6.0,  9.0
--    ,  0.0,  0.0,  0.0,  -4.0,  -5.0,  -6.0, 12.0, 15.0, 18.0
--    ,  0.0,  0.0,  0.0,  -7.0,  -8.0,  -9.0, 21.0, 24.0, 27.0
--    ,  0.0,  0.0,  0.0, -10.0, -11.0, -12.0, 30.0, 33.0, 36.0 ]
--   
kronecker :: Product t => Matrix t -> Matrix t -> Matrix t

-- | cross product (for three-element vectors)
cross :: Product t => Vector t -> Vector t -> Vector t
scale :: Linear t c => t -> c t -> c t
add :: Additive c => c -> c -> c

-- | the sum of elements
sumElements :: Container c e => c e -> e

-- | the product of elements
prodElements :: Container c e => c e -> e

-- | Least squares solution of a linear system, similar to the \ operator
--   of Matlab/Octave (based on linearSolveSVD)
--   
--   
--   a = (3><2)
--    [ 1.0,  2.0
--    , 2.0,  4.0
--    , 2.0, -1.0 ]
--   
--   
--   
--   v = vector [13.0,27.0,1.0]
--   
--   
--   
--   >>> let x = a <\> v
--   
--   >>> x
--   [3.0799999999999996,5.159999999999999]
--   it :: Vector Numeric.LinearAlgebra.Data.R
--   
--   
--   
--   >>> a #> x
--   [13.399999999999999,26.799999999999997,0.9999999999999991]
--   it :: Vector Numeric.LinearAlgebra.Data.R
--   
--   
--   It also admits multiple right-hand sides stored as columns in a
--   matrix.
(<\>) :: (LSDiv c, Field t) => Matrix t -> c t -> c t
infixl 7 <\>

-- | Least squared error solution of an overconstrained linear system, or
--   the minimum norm solution of an underconstrained system. For
--   rank-deficient systems use linearSolveSVD.
linearSolveLS :: Field t => Matrix t -> Matrix t -> Matrix t

-- | Minimum norm solution of a general linear least squares problem Ax=B
--   using the SVD. Admits rank-deficient systems but it is slower than
--   linearSolveLS. The effective rank of A is determined by
--   treating as zero those singular valures which are less than eps
--   times the largest singular value.
linearSolveSVD :: Field t => Matrix t -> Matrix t -> Matrix 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.
--   
--   
--   a = (2><2)
--    [ 1.0, 2.0
--    , 3.0, 5.0 ]
--   
--   
--   
--   b = (2><3)
--    [  6.0, 1.0, 10.0
--    , 15.0, 3.0, 26.0 ]
--   
--   
--   
--   >>> linearSolve a b
--   Just (2><3)
--    [ -1.4802973661668753e-15,     0.9999999999999997, 1.999999999999997
--    ,       3.000000000000001, 1.6653345369377348e-16, 4.000000000000002 ]
--   
--   
--   
--   >>> let Just x = it
--   
--   >>> disp 5 x
--   2x3
--   -0.00000  1.00000  2.00000
--    3.00000  0.00000  4.00000
--   
--   
--   
--   >>> a <> x
--   (2><3)
--    [  6.0, 1.0, 10.0
--    , 15.0, 3.0, 26.0 ]
--   
linearSolve :: Field t => Matrix t -> Matrix t -> Maybe (Matrix t)

-- | Solution of a linear system (for several right hand sides) from the
--   precomputed LU factorization obtained by luPacked.
luSolve :: Field t => LU t -> Matrix t -> Matrix t

-- | Obtains the LU decomposition of a matrix in a compact data structure
--   suitable for luSolve.
luPacked :: Field t => Matrix t -> LU t

-- | Experimental implementation of luSolve for any Fractional
--   element type, including Mod n I and Mod n
--   Z.
--   
--   
--   >>> let a = (2><2) [1,2,3,5] :: Matrix (Z ./. 13)
--   (2><2)
--    [ 1, 2
--    , 3, 5 ]
--   
--   >>> b
--   (2><3)
--    [ 5, 1, 3
--    , 8, 6, 3 ]
--   
--   
--   
--   >>> luSolve' (luPacked' a) b
--   (2><3)
--    [ 4,  7, 4
--    , 7, 10, 6 ]
--   
luSolve' :: (Fractional t, Container Vector t) => LU t -> Matrix t -> Matrix t

-- | Experimental implementation of luPacked for any Fractional
--   element type, including Mod n I and Mod n
--   Z.
--   
--   
--   >>> let m = ident 5 + (5><5) [0..] :: Matrix (Z ./. 17)
--   (5><5)
--    [  1,  1,  2,  3,  4
--    ,  5,  7,  7,  8,  9
--    , 10, 11, 13, 13, 14
--    , 15, 16,  0,  2,  2
--    ,  3,  4,  5,  6,  8 ]
--   
--   
--   
--   >>> let (l,u,p,s) = luFact $ luPacked' m
--   
--   >>> l
--   (5><5)
--    [  1,  0, 0,  0, 0
--    ,  6,  1, 0,  0, 0
--    , 12,  7, 1,  0, 0
--    ,  7, 10, 7,  1, 0
--    ,  8,  2, 6, 11, 1 ]
--   
--   >>> u
--   (5><5)
--    [ 15, 16,  0,  2,  2
--    ,  0, 13,  7, 13, 14
--    ,  0,  0, 15,  0, 11
--    ,  0,  0,  0, 15, 15
--    ,  0,  0,  0,  0,  1 ]
--   
luPacked' :: (Container Vector t, Fractional t, Normed (Vector t), Num (Vector t)) => Matrix t -> LU 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.
ldlSolve :: Field t => LDL t -> Matrix t -> Matrix t

-- | Obtains the LDL decomposition of a matrix in a compact data structure
--   suitable for ldlSolve.
ldlPacked :: Field t => Herm t -> LDL t

-- | Solve a symmetric or Hermitian positive definite linear system using a
--   precomputed Cholesky decomposition obtained by chol.
cholSolve :: Field t => Matrix t -> Matrix t -> Matrix t
data UpLo
Lower :: UpLo
Upper :: UpLo

-- | Solve a triangular linear system. If Upper is specified then
--   all elements below the diagonal are ignored; if Lower is
--   specified then all elements above the diagonal are ignored.
triSolve :: Field t => UpLo -> Matrix t -> Matrix t -> Matrix t

-- | Solve a tridiagonal linear system. Suppose you wish to solve
--   <math> where
--   
--   <math>
--   
--   then
--   
--   
--   dL =  fromList [3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0]
--   d  =  fromList [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0]
--   dU =  fromList [4.0, 4.0, 4.0, 4.0, 4.0, 4.0, 4.0, 4.0]
--   
--   b = (9><3)
--       [
--         1.0,   1.0,   1.0,
--         1.0,  -1.0,   2.0,
--         1.0,   1.0,   3.0,
--         1.0,  -1.0,   4.0,
--         1.0,   1.0,   5.0,
--         1.0,  -1.0,   6.0,
--         1.0,   1.0,   7.0,
--         1.0,  -1.0,   8.0,
--         1.0,   1.0,   9.0
--       ]
--   
--   x = triDiagSolve dL d dU b
--   
triDiagSolve :: Field t => Vector t -> Vector t -> Vector t -> Matrix t -> Matrix t

-- | Solve a sparse linear system using the conjugate gradient method with
--   default parameters.
cgSolve :: Bool -> GMatrix -> Vector R -> Vector R

-- | Solve a sparse linear system using the conjugate gradient method with
--   default parameters.
cgSolve' :: Bool -> R -> R -> Int -> GMatrix -> Vector R -> Vector R -> [CGState]

-- | Inverse of a square matrix. See also invlndet.
inv :: Field t => Matrix t -> Matrix t

-- | Pseudoinverse of a general matrix with default tolerance
--   (pinvTol 1, similar to GNU-Octave).
pinv :: Field t => Matrix t -> Matrix 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.
--   
--   
--   m = (3><3) [ 1, 0,    0
--              , 0, 1,    0
--              , 0, 0, 1e-10] :: Matrix Double
--   
--   
--   
--   >>> pinv m
--   1. 0.           0.
--   0. 1.           0.
--   0. 0. 10000000000.
--   
--   
--   
--   >>> pinvTol 1E8 m
--   1. 0. 0.
--   0. 1. 0.
--   0. 0. 1.
--   
pinvTol :: Field t => Double -> Matrix t -> Matrix t

-- | Reciprocal of the 2-norm condition number of a matrix, computed from
--   the singular values.
rcond :: Field t => Matrix t -> Double

-- | Number of linearly independent rows or columns. See also ranksv
rank :: Field t => Matrix t -> Int

-- | Determinant of a square matrix. To avoid possible overflow or
--   underflow use invlndet.
det :: Field t => Matrix t -> t

-- | Joint computation of inverse and logarithm of determinant of a square
--   matrix.
invlndet :: Field t => Matrix t -> (Matrix t, (t, t))

-- | p-norm for vectors, operator norm for matrices
class Normed a
norm_0 :: Normed a => a -> R
norm_1 :: Normed a => a -> R
norm_2 :: Normed a => a -> R
norm_Inf :: Normed a => a -> R

-- | Frobenius norm (Schatten p-norm with p=2)
norm_Frob :: (Normed (Vector t), Element t) => Matrix t -> R

-- | Sum of singular values (Schatten p-norm with p=1)
norm_nuclear :: Field t => Matrix t -> R

-- | return an orthonormal basis of the range space of a matrix. See also
--   orthSVD.
orth :: Field t => Matrix t -> Matrix t

-- | return an orthonormal basis of the null space of a matrix. See also
--   nullspaceSVD.
nullspace :: Field t => Matrix t -> Matrix t

-- | solution of overconstrained homogeneous linear system
null1 :: Matrix R -> Vector R

-- | solution of overconstrained homogeneous symmetric linear system
null1sym :: Herm R -> Vector R

-- | Full singular value decomposition.
--   
--   
--   a = (5><3)
--    [  1.0,  2.0,  3.0
--    ,  4.0,  5.0,  6.0
--    ,  7.0,  8.0,  9.0
--    , 10.0, 11.0, 12.0
--    , 13.0, 14.0, 15.0 ] :: Matrix Double
--   
--   
--   
--   >>> let (u,s,v) = svd a
--   
--   
--   
--   >>> disp 3 u
--   5x5
--   -0.101   0.768   0.614   0.028  -0.149
--   -0.249   0.488  -0.503   0.172   0.646
--   -0.396   0.208  -0.405  -0.660  -0.449
--   -0.543  -0.072  -0.140   0.693  -0.447
--   -0.690  -0.352   0.433  -0.233   0.398
--   
--   
--   
--   >>> s
--   [35.18264833189422,1.4769076999800903,1.089145439970417e-15]
--   it :: Vector Double
--   
--   
--   
--   >>> disp 3 v
--   3x3
--   -0.519  -0.751   0.408
--   -0.576  -0.046  -0.816
--   -0.632   0.659   0.408
--   
--   
--   
--   >>> let d = diagRect 0 s 5 3
--   
--   >>> disp 3 d
--   5x3
--   35.183  0.000  0.000
--    0.000  1.477  0.000
--    0.000  0.000  0.000
--    0.000  0.000  0.000
--   
--   
--   
--   >>> disp 3 $ u <> d <> tr v
--   5x3
--    1.000   2.000   3.000
--    4.000   5.000   6.000
--    7.000   8.000   9.000
--   10.000  11.000  12.000
--   13.000  14.000  15.000
--   
svd :: Field t => Matrix t -> (Matrix t, Vector Double, Matrix t)

-- | A version of svd which returns only the min (rows m) (cols
--   m) singular vectors of m.
--   
--   If (u,s,v) = thinSVD m then m == u <> diag s
--   <> tr v.
--   
--   
--   a = (5><3)
--    [  1.0,  2.0,  3.0
--    ,  4.0,  5.0,  6.0
--    ,  7.0,  8.0,  9.0
--    , 10.0, 11.0, 12.0
--    , 13.0, 14.0, 15.0 ] :: Matrix Double
--   
--   
--   
--   >>> let (u,s,v) = thinSVD a
--   
--   
--   
--   >>> disp 3 u
--   5x3
--   -0.101   0.768   0.614
--   -0.249   0.488  -0.503
--   -0.396   0.208  -0.405
--   -0.543  -0.072  -0.140
--   -0.690  -0.352   0.433
--   
--   
--   
--   >>> s
--   [35.18264833189422,1.4769076999800903,1.089145439970417e-15]
--   it :: Vector Double
--   
--   
--   
--   >>> disp 3 v
--   3x3
--   -0.519  -0.751   0.408
--   -0.576  -0.046  -0.816
--   -0.632   0.659   0.408
--   
--   
--   
--   >>> disp 3 $ u <> diag s <> tr v
--   5x3
--    1.000   2.000   3.000
--    4.000   5.000   6.000
--    7.000   8.000   9.000
--   10.000  11.000  12.000
--   13.000  14.000  15.000
--   
thinSVD :: Field t => Matrix t -> (Matrix t, Vector Double, Matrix t)

-- | Similar to thinSVD, returning only the nonzero singular values
--   and the corresponding singular vectors.
--   
--   
--   a = (5><3)
--    [  1.0,  2.0,  3.0
--    ,  4.0,  5.0,  6.0
--    ,  7.0,  8.0,  9.0
--    , 10.0, 11.0, 12.0
--    , 13.0, 14.0, 15.0 ] :: Matrix Double
--   
--   
--   
--   >>> let (u,s,v) = compactSVD a
--   
--   
--   
--   >>> disp 3 u
--   5x2
--   -0.101   0.768
--   -0.249   0.488
--   -0.396   0.208
--   -0.543  -0.072
--   -0.690  -0.352
--   
--   
--   
--   >>> s
--   [35.18264833189422,1.476907699980091]
--   it :: Vector Double
--   
--   
--   
--   >>> disp 3 u
--   5x2
--   -0.101   0.768
--   -0.249   0.488
--   -0.396   0.208
--   -0.543  -0.072
--   -0.690  -0.352
--   
--   
--   
--   >>> disp 3 $ u <> diag s <> tr v
--   5x3
--    1.000   2.000   3.000
--    4.000   5.000   6.000
--    7.000   8.000   9.000
--   10.000  11.000  12.000
--   13.000  14.000  15.000
--   
compactSVD :: Field t => Matrix t -> (Matrix t, Vector Double, Matrix t)

-- | compactSVDTol r is similar to compactSVD (for which
--   r=1), but uses tolerance tol=r*g*eps*(max rows cols)
--   to distinguish nonzero singular values, where g is the
--   greatest singular value. If g<r*eps, then only one
--   singular value is returned.
compactSVDTol :: Field t => Double -> Matrix t -> (Matrix t, Vector Double, Matrix t)

-- | Singular values only.
singularValues :: Field t => Matrix t -> Vector Double

-- | Singular values and all left singular vectors (as columns).
leftSV :: Field t => Matrix t -> (Matrix t, Vector Double)

-- | Singular values and all right singular vectors (as columns).
rightSV :: Field t => Matrix t -> (Vector Double, Matrix t)

-- | Eigenvalues (not ordered) and eigenvectors (as columns) of a general
--   square matrix.
--   
--   If (s,v) = eig m then m <> v == v <> diag
--   s
--   
--   
--   a = (3><3)
--    [ 3, 0, -2
--    , 4, 5, -1
--    , 3, 1,  0 ] :: Matrix Double
--   
--   
--   
--   >>> let (l, v) = eig a
--   
--   
--   
--   >>> putStr . dispcf 3 . asRow $ l
--   1x3
--   1.925+1.523i  1.925-1.523i  4.151
--   
--   
--   
--   >>> putStr . dispcf 3 $ v
--   3x3
--   -0.455+0.365i  -0.455-0.365i   0.181
--           0.603          0.603  -0.978
--    0.033+0.543i   0.033-0.543i  -0.104
--   
--   
--   
--   >>> putStr . dispcf 3 $ complex a <> v
--   3x3
--   -1.432+0.010i  -1.432-0.010i   0.753
--    1.160+0.918i   1.160-0.918i  -4.059
--   -0.763+1.096i  -0.763-1.096i  -0.433
--   
--   
--   
--   >>> putStr . dispcf 3 $ v <> diag l
--   3x3
--   -1.432+0.010i  -1.432-0.010i   0.753
--    1.160+0.918i   1.160-0.918i  -4.059
--   -0.763+1.096i  -0.763-1.096i  -0.433
--   
eig :: Field t => Matrix t -> (Vector (Complex Double), Matrix (Complex Double))

-- | Generalized eigenvalues (not ordered) and eigenvectors (as columns) of
--   a pair of nonsymmetric matrices. Eigenvalues are represented as pairs
--   of alpha, beta, where eigenvalue = alpha / beta. Alpha is always
--   complex, but betas has the same type as the input matrix.
--   
--   If (alphas, betas, v) = geig a b, then a <> v == b
--   <> v <> diag (alphas / betas)
--   
--   Note that beta can be 0 and that has reasonable interpretation.
geig :: Field t => Matrix t -> Matrix t -> (Vector (Complex Double), Vector t, Matrix (Complex Double))

-- | Eigenvalues and eigenvectors (as columns) of a complex hermitian or
--   real symmetric matrix, in descending order.
--   
--   If (s,v) = eigSH m then m == v <> diag s <>
--   tr v
--   
--   
--   a = (3><3)
--    [ 1.0, 2.0, 3.0
--    , 2.0, 4.0, 5.0
--    , 3.0, 5.0, 6.0 ]
--   
--   
--   
--   >>> let (l, v) = eigSH a
--   
--   
--   
--   >>> l
--   [11.344814282762075,0.17091518882717918,-0.5157294715892575]
--   
--   
--   
--   >>> disp 3 $ v <> diag l <> tr v
--   3x3
--   1.000  2.000  3.000
--   2.000  4.000  5.000
--   3.000  5.000  6.000
--   
eigSH :: Field t => Herm t -> (Vector Double, Matrix t)

-- | Eigenvalues (not ordered) of a general square matrix.
eigenvalues :: Field t => Matrix t -> Vector (Complex Double)

-- | Generalized eigenvalues of a pair of matrices. Represented as pairs of
--   alpha, beta, where eigenvalue is alpha / beta as in geig.
geigenvalues :: Field t => Matrix t -> Matrix t -> (Vector (Complex Double), Vector t)

-- | Eigenvalues (in descending order) of a complex hermitian or real
--   symmetric matrix.
eigenvaluesSH :: Field t => Herm t -> Vector Double

-- | Generalized symmetric positive definite eigensystem Av = lBv, for A
--   and B symmetric, B positive definite.
geigSH :: Field t => Herm t -> Herm t -> (Vector Double, Matrix t)

-- | QR factorization.
--   
--   If (q,r) = qr m then m == q <> r, where q is
--   unitary and r is upper triangular. Note: the current implementation is
--   very slow for large matrices. thinQR is much faster.
qr :: Field t => Matrix t -> (Matrix t, Matrix t)

-- | A version of qr which returns only the min (rows m) (cols
--   m) columns of q and rows of r.
thinQR :: Field t => Matrix t -> (Matrix t, Matrix t)

-- | RQ factorization.
--   
--   If (r,q) = rq m then m == r <> q, where q is
--   unitary and r is upper triangular. Note: the current implementation is
--   very slow for large matrices. thinRQ is much faster.
rq :: Field t => Matrix t -> (Matrix t, Matrix t)

-- | A version of rq which returns only the min (rows m) (cols
--   m) columns of r and rows of q.
thinRQ :: Field t => Matrix t -> (Matrix t, Matrix t)

-- | Compute the QR decomposition of a matrix in compact form.
qrRaw :: Field t => Matrix t -> QR t

-- | generate a matrix with k orthogonal columns from the compact QR
--   decomposition obtained by qrRaw.
qrgr :: Field t => Int -> QR t -> Matrix t

-- | Cholesky factorization of a positive definite hermitian or symmetric
--   matrix.
--   
--   If c = chol m then c is upper triangular and m
--   == tr c <> c.
chol :: Field t => Herm t -> Matrix t

-- | Similar to chol, but instead of an error (e.g., caused by a
--   matrix not positive definite) it returns Nothing.
mbChol :: Field t => Herm t -> Maybe (Matrix t)

-- | Explicit LU factorization of a general matrix.
--   
--   If (l,u,p,s) = lu m then 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.
lu :: Field t => Matrix t -> (Matrix t, Matrix t, Matrix t, t)

-- | Compute the explicit LU decomposition from the compact one obtained by
--   luPacked.
luFact :: Numeric t => LU t -> (Matrix t, Matrix t, Matrix t, t)

-- | Hessenberg factorization.
--   
--   If (p,h) = hess m then m == p <> h <> tr
--   p, where p is unitary and h is in upper Hessenberg form (it has
--   zero entries below the first subdiagonal).
hess :: Field t => Matrix t -> (Matrix t, Matrix t)

-- | Schur factorization.
--   
--   If (u,s) = schur m then m == u <> s <> tr
--   u, where u is unitary and s is a Shur matrix. A complex Schur
--   matrix is upper triangular. A real Schur matrix is upper triangular in
--   2x2 blocks.
--   
--   "Anything that the Jordan decomposition can do, the Schur
--   decomposition can do better!" (Van Loan)
schur :: Field t => Matrix t -> (Matrix t, Matrix t)

-- | Matrix exponential. It uses a direct translation of Algorithm 11.3.1
--   in Golub & Van Loan, based on a scaled Pade approximation.
expm :: Field t => Matrix t -> Matrix 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.
--   
--   
--   m = (2><2) [4,9
--              ,0,4] :: Matrix Double
--   
--   
--   
--   >>> sqrtm m
--   (2><2)
--    [ 2.0, 2.25
--    , 0.0,  2.0 ]
--   
--   
--   For diagonalizable matrices you can try matFunc sqrt:
--   
--   
--   >>> matFunc sqrt ((2><2) [1,0,0,-1])
--   (2><2)
--    [ 1.0 :+ 0.0, 0.0 :+ 0.0
--    , 0.0 :+ 0.0, 0.0 :+ 1.0 ]
--   
sqrtm :: Field t => Matrix t -> Matrix t

-- | Generic matrix functions for diagonalizable matrices. For instance:
--   
--   
--   logm = matFunc log
--   
matFunc :: (Complex Double -> Complex Double) -> Matrix (Complex Double) -> Matrix (Complex Double)

-- | correlation
--   
--   
--   >>> corr (fromList[1,2,3]) (fromList [1..10])
--   [14.0,20.0,26.0,32.0,38.0,44.0,50.0,56.0]
--   it :: (Enum t, Product t, Container Vector t) => Vector t
--   
corr :: (Container Vector t, Product t) => Vector t -> Vector t -> Vector t

-- | convolution (corr with reversed kernel and padded input,
--   equivalent to polynomial product)
--   
--   
--   >>> conv (fromList[1,1]) (fromList [-1,1])
--   [-1.0,0.0,1.0]
--   it :: (Product t, Container Vector t) => Vector t
--   
conv :: (Container Vector t, Product t, Num t) => Vector t -> Vector t -> Vector t

-- | similar to corr, using min instead of (*)
corrMin :: (Container Vector t, RealElement t, Product t) => Vector t -> Vector t -> Vector t

-- | 2D correlation (without padding)
--   
--   
--   >>> disp 5 $ corr2 (konst 1 (3,3)) (ident 10 :: Matrix Double)
--   8x8
--   3  2  1  0  0  0  0  0
--   2  3  2  1  0  0  0  0
--   1  2  3  2  1  0  0  0
--   0  1  2  3  2  1  0  0
--   0  0  1  2  3  2  1  0
--   0  0  0  1  2  3  2  1
--   0  0  0  0  1  2  3  2
--   0  0  0  0  0  1  2  3
--   
corr2 :: Product a => Matrix a -> Matrix a -> Matrix a

-- | 2D convolution
--   
--   
--   >>> disp 5 $ conv2 (konst 1 (3,3)) (ident 10 :: Matrix Double)
--   12x12
--   1  1  1  0  0  0  0  0  0  0  0  0
--   1  2  2  1  0  0  0  0  0  0  0  0
--   1  2  3  2  1  0  0  0  0  0  0  0
--   0  1  2  3  2  1  0  0  0  0  0  0
--   0  0  1  2  3  2  1  0  0  0  0  0
--   0  0  0  1  2  3  2  1  0  0  0  0
--   0  0  0  0  1  2  3  2  1  0  0  0
--   0  0  0  0  0  1  2  3  2  1  0  0
--   0  0  0  0  0  0  1  2  3  2  1  0
--   0  0  0  0  0  0  0  1  2  3  2  1
--   0  0  0  0  0  0  0  0  1  2  2  1
--   0  0  0  0  0  0  0  0  0  1  1  1
--   
conv2 :: (Num (Matrix a), Product a, Container Vector a) => Matrix a -> Matrix a -> Matrix a
type Seed = Int
data RandDist

-- | uniform distribution in [0,1)
Uniform :: RandDist

-- | normal distribution with mean zero and standard deviation one
Gaussian :: RandDist

-- | Obtains a vector of pseudorandom elements (use randomIO to get a
--   random seed).
randomVector :: Seed -> RandDist -> Int -> Vector Double

-- | pseudorandom matrix with uniform elements between 0 and 1
rand :: Int -> Int -> IO (Matrix Double)

-- | pseudorandom matrix with normal elements
--   
--   
--   >>> disp 3 =<< randn 3 5
--   3x5
--   0.386  -1.141   0.491  -0.510   1.512
--   0.069  -0.919   1.022  -0.181   0.745
--   0.313  -0.670  -0.097  -1.575  -0.583
--   
randn :: Int -> Int -> IO (Matrix Double)

-- | Obtains a matrix whose rows are pseudorandom samples from a
--   multivariate Gaussian distribution.
gaussianSample :: Seed -> Int -> Vector Double -> Herm Double -> Matrix Double

-- | Obtains a matrix whose rows are pseudorandom samples from a
--   multivariate uniform distribution.
uniformSample :: Seed -> Int -> [(Double, Double)] -> Matrix Double

-- | Compute mean vector and covariance matrix of the rows of a matrix.
--   
--   
--   >>> meanCov $ gaussianSample 666 1000 (fromList[4,5]) (trustSym $ diagl [2,3])
--   ([3.9933155655086696,5.061409102770331],Herm (2><2)
--    [    1.9963242906624408, -4.227815571404954e-2
--    , -4.227815571404954e-2,    3.2003833097832857 ])
--   it :: (Vector Double, Herm Double)
--   
meanCov :: Matrix Double -> (Vector Double, Herm Double)

-- | outer products of rows
--   
--   
--   >>> a
--   (3><2)
--    [   1.0,   2.0
--    ,  10.0,  20.0
--    , 100.0, 200.0 ]
--   
--   >>> b
--   (3><3)
--    [ 1.0, 2.0, 3.0
--    , 4.0, 5.0, 6.0
--    , 7.0, 8.0, 9.0 ]
--   
--   
--   
--   >>> rowOuters a (b ||| 1)
--   (3><8)
--    [   1.0,   2.0,   3.0,   1.0,    2.0,    4.0,    6.0,   2.0
--    ,  40.0,  50.0,  60.0,  10.0,   80.0,  100.0,  120.0,  20.0
--    , 700.0, 800.0, 900.0, 100.0, 1400.0, 1600.0, 1800.0, 200.0 ]
--   
rowOuters :: Matrix Double -> Matrix Double -> Matrix Double

-- | Matrix of pairwise squared distances of row vectors (using the matrix
--   product trick in blog.smola.org)
pairwiseD2 :: Matrix Double -> Matrix Double -> Matrix Double

-- | Obtains a vector in the same direction with 2-norm=1
normalize :: (Normed (Vector t), Num (Vector t), Field t) => Vector t -> Vector t

-- | 1 + 0.5*peps == 1, 1 + 0.6*peps /= 1
peps :: RealFloat x => x
relativeError :: Num a => (a -> Double) -> a -> a -> Double

-- | Check if the absolute value or complex magnitude is greater than a
--   given threshold
--   
--   
--   >>> magnit 1E-6 (1E-12 :: R)
--   False
--   
--   >>> magnit 1E-6 (3+iC :: C)
--   True
--   
--   >>> magnit 0 (3 :: I ./. 5)
--   True
--   
magnit :: (Element t, Normed (Vector t)) => R -> t -> Bool
haussholder :: Field a => a -> Vector a -> Matrix a
optimiseMult :: Monoid (Matrix t) => [Matrix t] -> Matrix t

-- | unconjugated dot product
udot :: Product e => Vector e -> Vector e -> e

-- | The nullspace of a matrix from its precomputed SVD decomposition.
nullspaceSVD :: Field t => Either Double Int -> Matrix t -> (Vector Double, Matrix t) -> Matrix t

-- | The range space a matrix from its precomputed SVD decomposition.
orthSVD :: Field t => Either Double Int -> Matrix t -> (Matrix t, Vector Double) -> Matrix t

-- | Numeric rank of a matrix from its singular values.
ranksv :: Double -> Int -> [Double] -> Int

-- | imaginary unit
iC :: C

-- | Compute the complex Hermitian or real symmetric part of a square
--   matrix ((x + tr x)/2).
sym :: Field t => Matrix t -> Herm t

-- | Compute the contraction tr x <> x of a general matrix.
mTm :: Numeric t => Matrix 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.
trustSym :: Matrix t -> Herm t

-- | Extract the general matrix from a Herm structure, forgetting
--   its symmetric or Hermitian property.
unSym :: Herm t -> Matrix t

-- | Supported matrix elements.
class Storable a => Element a

-- | Basic element-by-element functions for numeric containers
class Element e => Container (c :: Type -> Type) e

-- | Matrix product and related functions
class (Num e, Element e) => Product e
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
class LSDiv (c :: Type -> Type)

-- | 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.
data Herm t

-- | Structures that may contain complex numbers
class Complexable (c :: Type -> Type)

-- | Supported real types
class (Element t, Element Complex t, RealFloat t) => RealElement t
type family RealOf x
type ComplexOf x = Complex RealOf x
type family SingleOf x
type family DoubleOf x
type family IndexOf (c :: Type -> Type)

-- | Generic linear algebra functions for double precision real and complex
--   matrices.
--   
--   (Single precision data can be converted using single and
--   double).
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
class Linear t (c :: Type -> Type)
class Additive c
class Transposable m mt | m -> mt, mt -> m

-- | LU decomposition of a matrix in a compact format.
data LU t
LU :: Matrix t -> [Int] -> LU t

-- | LDL decomposition of a complex Hermitian or real symmetric matrix in a
--   compact format.
data LDL t
LDL :: Matrix t -> [Int] -> LDL t

-- | QR decomposition of a matrix in compact form. (The orthogonal matrix
--   is not explicitly formed.)
data QR t
QR :: Matrix t -> Vector t -> QR t
data CGState
CGState :: Vector R -> Vector R -> R -> Vector R -> R -> CGState

-- | conjugate gradient
[cgp] :: CGState -> Vector R

-- | residual
[cgr] :: CGState -> Vector R

-- | squared norm of residual
[cgr2] :: CGState -> R

-- | current solution
[cgx] :: CGState -> Vector R

-- | normalized size of correction
[cgdx] :: CGState -> R
class Testable t
checkT :: Testable t => t -> (Bool, IO ())
ioCheckT :: Testable t => t -> IO (Bool, IO ())

-- | compatibility with previous version, to be removed
module Numeric.LinearAlgebra.HMatrix

-- | a synonym for (|||) (unicode 0x00a6, broken bar)
(¦) :: Matrix Double -> Matrix Double -> Matrix Double
infixl 3 ¦

-- | a synonym for (===) (unicode 0x2014, em dash)
(——) :: Matrix Double -> Matrix Double -> Matrix Double
infixl 2 ——
type ℝ = Double
type ℂ = Complex Double
(<·>) :: Numeric t => Vector t -> Vector t -> t
infixr 8 <·>
app :: Numeric t => Matrix t -> Vector t -> Vector t
mul :: Numeric t => Matrix t -> Matrix t -> Matrix t

-- | Similar to chol, without checking that the input matrix is
--   hermitian or symmetric. It works with the upper triangular part.
cholSH :: Field t => Matrix t -> Matrix t

-- | Similar to cholSH, but instead of an error (e.g., caused by a
--   matrix not positive definite) it returns Nothing.
mbCholSH :: Field t => Matrix t -> Maybe (Matrix t)

-- | Similar to eigSH without checking that the input matrix is
--   hermitian or symmetric. It works with the upper triangular part.
eigSH' :: Field t => Matrix t -> (Vector Double, Matrix t)

-- | Similar to eigenvaluesSH without checking that the input matrix
--   is hermitian or symmetric. It works with the upper triangular part.
eigenvaluesSH' :: Field t => Matrix t -> Vector Double
geigSH' :: Field t => Matrix t -> Matrix t -> (Vector Double, Matrix t)

-- | Experimental interface with statically checked dimensions.
--   
--   See code examples at
--   http://dis.um.es/~alberto/hmatrix/static.html.
module Numeric.LinearAlgebra.Static
type ℝ = Double
data R (n :: Nat)
vec2 :: ℝ -> ℝ -> R 2
vec3 :: ℝ -> ℝ -> ℝ -> R 3
vec4 :: ℝ -> ℝ -> ℝ -> ℝ -> R 4
(&) :: forall (n :: Nat). KnownNat n => R n -> ℝ -> R (n + 1)
infixl 4 &
(#) :: forall (n :: Nat) (m :: Nat). (KnownNat n, KnownNat m) => R n -> R m -> R (n + m)
infixl 4 #
split :: forall (p :: Nat) (n :: Nat). (KnownNat p, KnownNat n, p <= n) => R n -> (R p, R (n - p))
headTail :: forall (n :: Nat). (KnownNat n, 1 <= n) => R n -> (ℝ, R (n - 1))
vector :: forall (n :: Nat). KnownNat n => [ℝ] -> R n
linspace :: forall (n :: Nat). KnownNat n => (ℝ, ℝ) -> R n
range :: forall (n :: Nat). KnownNat n => R n
dim :: forall (n :: Nat). KnownNat n => R n
data L (m :: Nat) (n :: Nat)
type Sq (n :: Nat) = L n n
build :: forall (m :: Nat) (n :: Nat). (KnownNat n, KnownNat m) => (ℝ -> ℝ -> ℝ) -> L m n
row :: forall (n :: Nat). R n -> L 1 n
col :: forall {n :: Nat}. KnownNat n => R n -> L n 1
(|||) :: forall {c :: Nat} {r1 :: Nat} {r2 :: Nat}. (KnownNat c, KnownNat r1, KnownNat r2, KnownNat (r1 + r2)) => L c r1 -> L c r2 -> L c (r1 + r2)
infixl 3 |||
(===) :: forall (r1 :: Nat) (r2 :: Nat) (c :: Nat). (KnownNat r1, KnownNat r2, KnownNat c) => L r1 c -> L r2 c -> L (r1 + r2) c
infixl 2 ===
splitRows :: forall (p :: Nat) (m :: Nat) (n :: Nat). (KnownNat p, KnownNat m, KnownNat n, p <= m) => L m n -> (L p n, L (m - p) n)
splitCols :: forall (p :: Nat) (m :: Nat) (n :: Nat). (KnownNat p, KnownNat m, KnownNat n, KnownNat (n - p), p <= n) => L m n -> (L m p, L m (n - p))
unrow :: forall (n :: Nat). L 1 n -> R n
uncol :: forall {n :: Nat}. KnownNat n => L n 1 -> R n

-- | conjugate transpose
tr :: Transposable m mt => m -> mt
eye :: forall (n :: Nat). KnownNat n => Sq n
diag :: forall (n :: Nat). KnownNat n => R n -> Sq n
blockAt :: forall (m :: Nat) (n :: Nat). (KnownNat m, KnownNat n) => ℝ -> Int -> Int -> Matrix Double -> L m n
matrix :: forall (m :: Nat) (n :: Nat). (KnownNat m, KnownNat n) => [ℝ] -> L m n
type ℂ = Complex Double
data C (n :: Nat)
data M (m :: Nat) (n :: Nat)
data Her (n :: Nat)
her :: forall (n :: Nat). KnownNat n => M n n -> Her n
𝑖 :: forall s (c :: Type -> Type). Sized ℂ s c => s
toComplex :: forall (n :: Nat). KnownNat n => (R n, R n) -> C n
fromComplex :: forall (n :: Nat). KnownNat n => C n -> (R n, R n)
complex :: forall (n :: Nat). KnownNat n => R n -> C n
real :: forall (n :: Nat). KnownNat n => C n -> R n
imag :: forall (n :: Nat). KnownNat n => C n -> R n
sqMagnitude :: forall (n :: Nat). KnownNat n => C n -> R n
magnitude :: forall (n :: Nat). KnownNat n => C n -> R n
(<>) :: forall (m :: Nat) (k :: Nat) (n :: Nat). (KnownNat m, KnownNat k, KnownNat n) => L m k -> L k n -> L m n
infixr 8 <>
(#>) :: forall (m :: Nat) (n :: Nat). (KnownNat m, KnownNat n) => L m n -> R n -> R m
infixr 8 #>
(<.>) :: forall (n :: Nat). KnownNat n => R n -> R n -> ℝ
infixr 8 <.>
linSolve :: forall (m :: Nat) (n :: Nat). (KnownNat m, KnownNat n) => L m m -> L m n -> Maybe (L m n)
(<\>) :: forall (m :: Nat) (n :: Nat) (r :: Nat). (KnownNat m, KnownNat n, KnownNat r) => L m n -> L m r -> L n r
svd :: forall (m :: Nat) (n :: Nat). (KnownNat m, KnownNat n) => L m n -> (L m m, R n, L n n)
withCompactSVD :: forall (m :: Nat) (n :: Nat) z. (KnownNat m, KnownNat n) => L m n -> (forall (k :: Nat). KnownNat k => (L m k, R k, L n k) -> z) -> z
svdTall :: forall (m :: Nat) (n :: Nat). (KnownNat m, KnownNat n, n <= m) => L m n -> (L m n, R n, L n n)
svdFlat :: forall (m :: Nat) (n :: Nat). (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
eigensystem :: Eigen m l v => m -> (l, v)
eigenvalues :: Eigen m l v => m -> l
withNullspace :: forall (m :: Nat) (n :: Nat) z. (KnownNat m, KnownNat n) => L m n -> (forall (k :: Nat). KnownNat k => L n k -> z) -> z
withOrth :: forall (m :: Nat) (n :: Nat) z. (KnownNat m, KnownNat n) => L m n -> (forall (k :: Nat). KnownNat k => L n k -> z) -> z
qr :: forall (m :: Nat) (n :: Nat). (KnownNat m, KnownNat n) => L m n -> (L m m, L m n)
chol :: forall (n :: Nat). KnownNat n => Sym n -> Sq n

-- | p-norm for vectors, operator norm for matrices
class Normed a
norm_0 :: Normed a => a -> R
norm_1 :: Normed a => a -> R
norm_2 :: Normed a => a -> R
norm_Inf :: Normed a => a -> R
type Seed = Int
data RandDist

-- | uniform distribution in [0,1)
Uniform :: RandDist

-- | normal distribution with mean zero and standard deviation one
Gaussian :: RandDist
randomVector :: forall (n :: Nat). KnownNat n => Seed -> RandDist -> R n
rand :: forall (m :: Nat) (n :: Nat). (KnownNat m, KnownNat n) => IO (L m n)
randn :: forall (m :: Nat) (n :: Nat). (KnownNat m, KnownNat n) => IO (L m n)
gaussianSample :: forall (m :: Nat) (n :: Nat). (KnownNat m, KnownNat n) => Seed -> R n -> Sym n -> L m n
uniformSample :: forall (m :: Nat) (n :: Nat). (KnownNat m, KnownNat n) => Seed -> R n -> R n -> L m n
mean :: forall (n :: Nat). (KnownNat n, 1 <= n) => R n -> ℝ
meanCov :: forall (m :: Nat) (n :: Nat). (KnownNat m, KnownNat n, 1 <= m) => L m n -> (R n, Sym n)
class Disp t
disp :: Disp t => Int -> t -> IO ()
class Domain field (vec :: Nat -> Type) (mat :: Nat -> Nat -> Type) | mat -> vec field, vec -> mat field, field -> mat vec
mul :: forall (m :: Nat) (k :: Nat) (n :: Nat). (Domain field vec mat, KnownNat m, KnownNat k, KnownNat n) => mat m k -> mat k n -> mat m n
app :: forall (m :: Nat) (n :: Nat). (Domain field vec mat, KnownNat m, KnownNat n) => mat m n -> vec n -> vec m
dot :: forall (n :: Nat). (Domain field vec mat, KnownNat n) => vec n -> vec n -> field
cross :: Domain field vec mat => vec 3 -> vec 3 -> vec 3
diagR :: forall (m :: Nat) (n :: Nat) (k :: Nat). (Domain field vec mat, KnownNat m, KnownNat n, KnownNat k) => field -> vec k -> mat m n
dvmap :: forall (n :: Nat). (Domain field vec mat, KnownNat n) => (field -> field) -> vec n -> vec n
dmmap :: forall (n :: Nat) (m :: Nat). (Domain field vec mat, KnownNat m, KnownNat n) => (field -> field) -> mat n m -> mat n m
outer :: forall (n :: Nat) (m :: Nat). (Domain field vec mat, KnownNat m, KnownNat n) => vec n -> vec m -> mat n m
zipWithVector :: forall (n :: Nat). (Domain field vec mat, KnownNat n) => (field -> field -> field) -> vec n -> vec n -> vec n
det :: forall (n :: Nat). (Domain field vec mat, KnownNat n) => mat n n -> field
invlndet :: forall (n :: Nat). (Domain field vec mat, KnownNat n) => mat n n -> (mat n n, (field, field))
expm :: forall (n :: Nat). (Domain field vec mat, KnownNat n) => mat n n -> mat n n
sqrtm :: forall (n :: Nat). (Domain field vec mat, KnownNat n) => mat n n -> mat n n
inv :: forall (n :: Nat). (Domain field vec mat, KnownNat n) => mat n n -> mat n n
withVector :: Vector ℝ -> (forall (n :: Nat). KnownNat n => R n -> z) -> z
withMatrix :: Matrix ℝ -> (forall (m :: Nat) (n :: Nat). (KnownNat m, KnownNat n) => L m n -> z) -> z

-- | Useful for constraining two dependently typed vectors to match each
--   other in length when they are unknown at compile-time.
exactLength :: forall (n :: Nat) (m :: Nat). (KnownNat n, KnownNat m) => R m -> Maybe (R n)

-- | Useful for constraining two dependently typed matrices to match each
--   other in dimensions when they are unknown at compile-time.
exactDims :: forall (n :: Nat) (m :: Nat) (j :: Nat) (k :: Nat). (KnownNat n, KnownNat m, KnownNat j, KnownNat k) => L m n -> Maybe (L j k)
toRows :: forall (m :: Nat) (n :: Nat). (KnownNat m, KnownNat n) => L m n -> [R n]
toColumns :: forall (m :: Nat) (n :: Nat). (KnownNat m, KnownNat n) => L m n -> [R m]
withRows :: forall (n :: Nat) z. KnownNat n => [R n] -> (forall (m :: Nat). KnownNat m => L m n -> z) -> z
withColumns :: forall (m :: Nat) z. KnownNat m => [R m] -> (forall (n :: Nat). KnownNat n => L m n -> z) -> z
class Num t => Sized t s (d :: Type -> Type) | s -> t, s -> d
konst :: Sized t s d => t -> s
unwrap :: Sized t s d => s -> d t
fromList :: Sized t s d => [t] -> s
extract :: Sized t s d => s -> d t
create :: Sized t s d => d t -> Maybe s
size :: Sized t s d => s -> IndexOf d
class Diag m d | m -> d
takeDiag :: Diag m d => m -> d
data Sym (n :: Nat)
sym :: forall (n :: Nat). KnownNat n => Sq n -> Sym n
mTm :: forall (m :: Nat) (n :: Nat). (KnownNat m, KnownNat n) => L m n -> Sym n
unSym :: forall (n :: Nat). Sym n -> Sq n
(<·>) :: forall (n :: Nat). KnownNat n => R n -> R n -> ℝ
infixr 8 <·>
instance GHC.Internal.TypeNats.KnownNat n => Internal.Numeric.Additive (Numeric.LinearAlgebra.Static.Sym n)
instance GHC.Internal.TypeNats.KnownNat n => Numeric.LinearAlgebra.Static.Diag (Internal.Static.L n n) (Internal.Static.R n)
instance GHC.Internal.TypeNats.KnownNat n => Numeric.LinearAlgebra.Static.Diag (Internal.Static.M n n) (Internal.Static.C n)
instance GHC.Internal.TypeNats.KnownNat n => Internal.Static.Disp (Numeric.LinearAlgebra.Static.Her n)
instance GHC.Internal.TypeNats.KnownNat n => Internal.Static.Disp (Numeric.LinearAlgebra.Static.Sym n)
instance Numeric.LinearAlgebra.Static.Domain Internal.Static.ℂ Internal.Static.C Internal.Static.M
instance Numeric.LinearAlgebra.Static.Domain Internal.Static.ℝ Internal.Static.R Internal.Static.L
instance GHC.Internal.TypeNats.KnownNat n => Numeric.LinearAlgebra.Static.Eigen (Numeric.LinearAlgebra.Static.Sq n) (Internal.Static.C n) (Internal.Static.M n n)
instance GHC.Internal.TypeNats.KnownNat n => Numeric.LinearAlgebra.Static.Eigen (Numeric.LinearAlgebra.Static.Sym n) (Internal.Static.R n) (Internal.Static.L n n)
instance GHC.Internal.TypeNats.KnownNat n => GHC.Internal.Float.Floating (Numeric.LinearAlgebra.Static.Sym n)
instance GHC.Internal.TypeNats.KnownNat n => GHC.Internal.Real.Fractional (Numeric.LinearAlgebra.Static.Sym n)
instance (GHC.Internal.TypeNats.KnownNat m, GHC.Internal.TypeNats.KnownNat n) => Internal.Util.Normed (Internal.Static.L m n)
instance GHC.Internal.TypeNats.KnownNat n => Internal.Util.Normed (Internal.Static.R n)
instance GHC.Internal.TypeNats.KnownNat n => GHC.Internal.Num.Num (Numeric.LinearAlgebra.Static.Sym n)
instance GHC.Internal.TypeNats.KnownNat n => GHC.Internal.Show.Show (Numeric.LinearAlgebra.Static.Sym n)
instance (GHC.Internal.TypeNats.KnownNat n', GHC.Internal.TypeNats.KnownNat m') => Internal.Numeric.Testable (Internal.Static.L n' m')
instance GHC.Internal.TypeNats.KnownNat n => Internal.Numeric.Transposable (Numeric.LinearAlgebra.Static.Her n) (Numeric.LinearAlgebra.Static.Her n)
instance GHC.Internal.TypeNats.KnownNat n => Internal.Numeric.Transposable (Numeric.LinearAlgebra.Static.Sym n) (Numeric.LinearAlgebra.Static.Sym n)
