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


-- | Linear Algebra on Typed Spaces
--   
--   Please see README.org
@package LATS
@version 0.4.1

module LinearAlgebra.TypedSpaces.Vector.Mutable

module LinearAlgebra.TypedSpaces.Vector.Raw

module LinearAlgebra.TypedSpaces.Matrix.Raw

module LinearAlgebra.TypedSpaces.Classes
class Isomorphism a b
fw :: Isomorphism a b => a -> b
bw :: Isomorphism a b => b -> a
class CFunctor f => CZippable f
czipWith :: (CZippable f, CFun f a, CFun f b, CFun f c) => (a -> b -> c) -> f a -> f b -> f c
czipWith3 :: (CZippable f, CFun f a, CFun f b, CFun f c, CFun f d) => (a -> b -> c -> d) -> f a -> f b -> f c -> f d
czipWith4 :: (CZippable f, CFun f a, CFun f b, CFun f c, CFun f d, CFun f e) => (a -> b -> c -> d -> e) -> f a -> f b -> f c -> f d -> f e
class CFunctor f => CIndexed f i | f -> i
(!) :: (CIndexed f i, CFun f a) => f a -> i -> a

-- | The <a>IsList</a> class and its methods are intended to be used in
--   conjunction with the OverloadedLists extension.
class IsList l where type family Item l :: *

-- | The <a>fromList</a> function constructs the structure <tt>l</tt> from
--   the given list of <tt>Item l</tt>
fromList :: IsList l => [Item l] -> l

-- | The <a>fromListN</a> function takes the input list's length as a hint.
--   Its behaviour should be equivalent to <a>fromList</a>. The hint can be
--   used to construct the structure <tt>l</tt> more efficiently compared
--   to <a>fromList</a>. If the given hint does not equal to the input
--   list's length the behaviour of <a>fromListN</a> is not specified.
fromListN :: IsList l => Int -> [Item l] -> l

-- | The <a>toList</a> function extracts a list of <tt>Item l</tt> from the
--   structure <tt>l</tt>. It should satisfy fromList . toList = id.
toList :: IsList l => l -> [Item l]

module LinearAlgebra.TypedSpaces.Vector
newtype Vector i a
Vector :: Vector a -> Vector i a
[vector] :: Vector i a -> Vector a
instance (GHC.Classes.Eq a, Foreign.Storable.Storable a) => GHC.Classes.Eq (LinearAlgebra.TypedSpaces.Vector.Vector i a)
instance (GHC.Show.Show a, Foreign.Storable.Storable a) => GHC.Show.Show (LinearAlgebra.TypedSpaces.Vector.Vector i a)
instance LinearAlgebra.TypedSpaces.Classes.Isomorphism GHC.Types.Int i => LinearAlgebra.TypedSpaces.Classes.CIndexed (LinearAlgebra.TypedSpaces.Vector.Vector i) i
instance Control.ConstraintClasses.CFunctor (LinearAlgebra.TypedSpaces.Vector.Vector i)
instance Control.ConstraintClasses.CFoldable (LinearAlgebra.TypedSpaces.Vector.Vector i)
instance Foreign.Storable.Storable a => Data.Semigroup.Semigroup (LinearAlgebra.TypedSpaces.Vector.Vector i a)
instance Foreign.Storable.Storable a => GHC.Base.Monoid (LinearAlgebra.TypedSpaces.Vector.Vector i a)
instance LinearAlgebra.TypedSpaces.Classes.CZippable (LinearAlgebra.TypedSpaces.Vector.Vector i)
instance Foreign.Storable.Storable a => GHC.Exts.IsList (LinearAlgebra.TypedSpaces.Vector.Vector i a)

module LinearAlgebra.TypedSpaces.Matrix
newtype Matrix i j a
Matrix :: Matrix a -> Matrix i j a
[matrix] :: Matrix i j a -> Matrix a

-- | The member functions of this class facilitate writing values of
--   primitive types to raw memory (which may have been allocated with the
--   above mentioned routines) and reading values from blocks of raw
--   memory. The class, furthermore, includes support for computing the
--   storage requirements and alignment restrictions of storable types.
--   
--   Memory addresses are represented as values of type <tt><a>Ptr</a>
--   a</tt>, for some <tt>a</tt> which is an instance of class
--   <a>Storable</a>. The type argument to <a>Ptr</a> helps provide some
--   valuable type safety in FFI code (you can't mix pointers of different
--   types without an explicit cast), while helping the Haskell type system
--   figure out which marshalling method is needed for a given pointer.
--   
--   All marshalling between Haskell and a foreign language ultimately
--   boils down to translating Haskell data structures into the binary
--   representation of a corresponding data structure of the foreign
--   language and vice versa. To code this marshalling in Haskell, it is
--   necessary to manipulate primitive data types stored in unstructured
--   memory blocks. The class <a>Storable</a> facilitates this manipulation
--   on all types for which it is instantiated, which are the standard
--   basic types of Haskell, the fixed size <tt>Int</tt> types
--   (<a>Int8</a>, <a>Int16</a>, <a>Int32</a>, <a>Int64</a>), the fixed
--   size <tt>Word</tt> types (<a>Word8</a>, <a>Word16</a>, <a>Word32</a>,
--   <a>Word64</a>), <a>StablePtr</a>, all types from
--   <a>Foreign.C.Types</a>, as well as <a>Ptr</a>.
class Storable a

-- | Supported matrix elements.
class Storable a => Element a
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

-- | Generic linear algebra functions for double precision real and complex
--   matrices.
--   
--   (Single precision data can be converted using <a>single</a> and
--   <a>double</a>).
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
rows :: Matrix i j a -> Int
cols :: Matrix i j a -> Int
fromRows :: Element a => [Vector j a] -> Matrix i j a
toRows :: Element a => Matrix i j a -> [Vector j a]
fromColumns :: Element a => [Vector i a] -> Matrix i j a
toColumns :: Element a => Matrix i j a -> [Vector i a]
takeRows :: Element a => Int -> Matrix i j a -> Matrix i j a
takeColumns :: Element a => Int -> Matrix i j a -> Matrix i j a
tr :: (Transposable (Matrix a) (Matrix a)) => Matrix i j a -> Matrix j i a
newtype Sparse i j a
Sparse :: [((Int, Int), a)] -> Sparse i j a
[sparse] :: Sparse i j a -> [((Int, Int), a)]
toDense :: Sparse i j Double -> Matrix i j Double
addToSparse :: (Isomorphism Int i, Isomorphism Int j) => ((i, j), a) -> Sparse i j a -> Sparse i j a
(<.>) :: (Numeric a) => Vector i a -> Vector i a -> a
(#>) :: (Numeric a) => Matrix i j a -> Vector j a -> Vector i a
(<#) :: (Numeric a) => Vector i a -> Matrix i j a -> Vector j a
(#) :: (Numeric a) => Matrix i j a -> Matrix j k a -> Matrix i k a
inv :: (Field a) => Matrix i j a -> Matrix j i a
pinv :: (Field a) => Matrix i j a -> Matrix j i a
instance GHC.Show.Show a => GHC.Show.Show (LinearAlgebra.TypedSpaces.Matrix.Sparse i j a)
instance (GHC.Show.Show a, Internal.Matrix.Element a) => GHC.Show.Show (LinearAlgebra.TypedSpaces.Matrix.Matrix i j a)
instance (LinearAlgebra.TypedSpaces.Classes.Isomorphism GHC.Types.Int i, LinearAlgebra.TypedSpaces.Classes.Isomorphism GHC.Types.Int j) => LinearAlgebra.TypedSpaces.Classes.CIndexed (LinearAlgebra.TypedSpaces.Matrix.Matrix i j) (i, j)
instance Control.ConstraintClasses.CFunctor (LinearAlgebra.TypedSpaces.Matrix.Matrix i j)

module LinearAlgebra.TypedSpaces