Eigen.Internal

Internal module to Eigen. Here we define all foreign function calls, and some typeclasses integral to the public and private interfaces of the library.

Documentation

data Row (r :: Nat)

Like Proxy, but specialised to Nat.

Constructors

Row

data Col (c :: Nat)

Like Proxy, but specialised to Nat.

Constructors

Col

natToInt :: forall n. KnownNat n => Int

Used internally. Given a KnownNat constraint, turn the type-level Nat into an Int.

class Cast (a :: Type) where

Cast to and from a C-FFI type Cast is a closed typeclass with an associated injective type family. It is closed in the sense that we provide only four types with instances for it; and intend for eigen to only be used with those four types. The injectivity of the type family is then useful for avoiding MPTCs. Cast has two functions; toC and fromC, where toC goes from a Haskell type to its associated C type for internal use, with the C FFI, and fromC goes from the associated C type to the Haskell type.

Minimal complete definition

toC, fromC

Associated Types

type C a = (result :: Type) | result -> a

Methods

toC :: a -> C a

fromC :: C a -> a

Instances

Cast Double

Defined in Eigen.Internal

Associated Types

type C Double = (result :: Type)

Methods

toC :: Double -> C Double

fromC :: C Double -> Double

Cast Float

Defined in Eigen.Internal

Associated Types

type C Float = (result :: Type)

Methods

toC :: Float -> C Float

fromC :: C Float -> Float

Cast Int

Defined in Eigen.Internal

Associated Types

type C Int = (result :: Type)

Methods

toC :: Int -> C Int

fromC :: C Int -> Int

Cast a => Cast (Complex a)

Defined in Eigen.Internal

Associated Types

type C (Complex a) = (result :: Type)

Methods

toC :: Complex a -> C (Complex a)

fromC :: C (Complex a) -> Complex a

Cast a => Cast (Int, Int, a)

WARNING! toC is lossy for any Int greater than (maxBound :: Int32)!

Defined in Eigen.Internal

Associated Types

type C (Int, Int, a) = (result :: Type)

Methods

toC :: (Int, Int, a) -> C (Int, Int, a)

fromC :: C (Int, Int, a) -> (Int, Int, a)

data CComplex a

Complex number for FFI with the same memory layout as std::complex<T>

Constructors

CComplex !a !a

Instances

Show a => Show (CComplex a)

Defined in Eigen.Internal

Methods

showsPrec :: Int -> CComplex a -> ShowS

show :: CComplex a -> String

showList :: [CComplex a] -> ShowS

Storable a => Storable (CComplex a)

Defined in Eigen.Internal

Methods

sizeOf :: CComplex a -> Int

alignment :: CComplex a -> Int

peekElemOff :: Ptr (CComplex a) -> Int -> IO (CComplex a)

pokeElemOff :: Ptr (CComplex a) -> Int -> CComplex a -> IO ()

peekByteOff :: Ptr b -> Int -> IO (CComplex a)

pokeByteOff :: Ptr b -> Int -> CComplex a -> IO ()

peek :: Ptr (CComplex a) -> IO (CComplex a)

poke :: Ptr (CComplex a) -> CComplex a -> IO ()

Code (CComplex CFloat)

Defined in Eigen.Internal

Methods

code :: CComplex CFloat -> CInt

Code (CComplex CDouble)

Defined in Eigen.Internal

Methods

code :: CComplex CDouble -> CInt

data CTriplet a where

FIXME: Doc

Constructors

CTriplet :: Cast a => !CInt -> !CInt -> !(C a) -> CTriplet a

Instances

(Show a, Show (C a)) => Show (CTriplet a)

Defined in Eigen.Internal

Methods

showsPrec :: Int -> CTriplet a -> ShowS

show :: CTriplet a -> String

showList :: [CTriplet a] -> ShowS

(Storable a, Elem a) => Storable (CTriplet a)

Defined in Eigen.Internal

Methods

sizeOf :: CTriplet a -> Int

alignment :: CTriplet a -> Int

peekElemOff :: Ptr (CTriplet a) -> Int -> IO (CTriplet a)

pokeElemOff :: Ptr (CTriplet a) -> Int -> CTriplet a -> IO ()

peekByteOff :: Ptr b -> Int -> IO (CTriplet a)

pokeByteOff :: Ptr b -> Int -> CTriplet a -> IO ()

peek :: Ptr (CTriplet a) -> IO (CTriplet a)

poke :: Ptr (CTriplet a) -> CTriplet a -> IO ()

class (Num a, Cast a, Storable a, Storable (C a), Code (C a)) => Elem a

Elem is a closed typeclass that encompasses the properties eigen expects its values to possess, and simplifies the external API quite a bit.

Instances

Elem Double

Defined in Eigen.Internal

Elem Float

Defined in Eigen.Internal

Elem (Complex Double)

Defined in Eigen.Internal

Elem (Complex Float)

Defined in Eigen.Internal

class Code a where

Encode a C Type as a CInt

Hack used in FFI wrapper functions when constructing FFI calls

Minimal complete definition

code

Methods

code :: a -> CInt

Instances

Code CFloat

Defined in Eigen.Internal

Methods

code :: CFloat -> CInt

Code CDouble

Defined in Eigen.Internal

Methods

code :: CDouble -> CInt

Code SparseQR

Defined in Eigen.Solver.SparseLA

Methods

code :: SparseQR -> CInt

Code SparseLU

Defined in Eigen.Solver.SparseLA

Methods

code :: SparseLU -> CInt

Code BiCGSTAB

Defined in Eigen.Solver.SparseLA

Methods

code :: BiCGSTAB -> CInt

Code ConjugateGradient

Defined in Eigen.Solver.SparseLA

Methods

code :: ConjugateGradient -> CInt

Code (CComplex CFloat)

Defined in Eigen.Internal

Methods

code :: CComplex CFloat -> CInt

Code (CComplex CDouble)

Defined in Eigen.Internal

Methods

code :: CComplex CDouble -> CInt

newtype MagicCode

Hack used in constructing FFI calls.

Constructors

MagicCode CInt

Instances

Eq MagicCode

Defined in Eigen.Internal

Methods

(==) :: MagicCode -> MagicCode -> Bool

(/=) :: MagicCode -> MagicCode -> Bool

Binary MagicCode

Defined in Eigen.Internal

Methods

put :: MagicCode -> Put

get :: Get MagicCode

putList :: [MagicCode] -> Put

magicCode :: Code a => a -> MagicCode

Hack used in constructing FFI calls.

intSize :: Int

Machine size of a CInt.

encodeInt :: CInt -> ByteString

FIXME: Doc

decodeInt :: ByteString -> CInt

FIXME: Doc

data CSparseMatrix a

FIXME: Doc

type CSparseMatrixPtr a = Ptr (CSparseMatrix a)

FIXME: Doc

data CSolver a

FIXME: Doc

type CSolverPtr a = Ptr (CSolver a)

FIXME: Doc

performIO :: IO a -> a

FIXME: replace with unholyPerformIO (?)

plusForeignPtr :: ForeignPtr a -> Int -> ForeignPtr b

FIXME: Doc

c_freeString :: CString -> IO ()

call :: IO CString -> IO ()

free :: Ptr a -> IO ()

c_setNbThreads :: CInt -> IO ()

c_getNbThreads :: IO CInt

c_random :: CInt -> Ptr (C a) -> CInt -> CInt -> IO CString

random :: forall a. Code (C a) => Ptr (C a) -> CInt -> CInt -> IO CString

c_identity :: CInt -> Ptr (C a) -> CInt -> CInt -> IO CString

identity :: forall a. Code (C a) => Ptr (C a) -> CInt -> CInt -> IO CString

c_add :: CInt -> Ptr (C a) -> CInt -> CInt -> Ptr (C a) -> CInt -> CInt -> Ptr (C a) -> CInt -> CInt -> IO CString

add :: forall a. Code (C a) => Ptr (C a) -> CInt -> CInt -> Ptr (C a) -> CInt -> CInt -> Ptr (C a) -> CInt -> CInt -> IO CString

c_sub :: CInt -> Ptr (C a) -> CInt -> CInt -> Ptr (C a) -> CInt -> CInt -> Ptr (C a) -> CInt -> CInt -> IO CString

sub :: forall a. Code (C a) => Ptr (C a) -> CInt -> CInt -> Ptr (C a) -> CInt -> CInt -> Ptr (C a) -> CInt -> CInt -> IO CString

c_mul :: CInt -> Ptr (C a) -> CInt -> CInt -> Ptr (C a) -> CInt -> CInt -> Ptr (C a) -> CInt -> CInt -> IO CString

c_diagonal :: CInt -> Ptr (C a) -> CInt -> CInt -> Ptr (C a) -> CInt -> CInt -> IO CString

mul :: forall a. Code (C a) => Ptr (C a) -> CInt -> CInt -> Ptr (C a) -> CInt -> CInt -> Ptr (C a) -> CInt -> CInt -> IO CString

diagonal :: forall a. Code (C a) => Ptr (C a) -> CInt -> CInt -> Ptr (C a) -> CInt -> CInt -> IO CString

c_transpose :: CInt -> Ptr (C a) -> CInt -> CInt -> Ptr (C a) -> CInt -> CInt -> IO CString

transpose :: forall a. Code (C a) => Ptr (C a) -> CInt -> CInt -> Ptr (C a) -> CInt -> CInt -> IO CString

c_inverse :: CInt -> Ptr (C a) -> CInt -> CInt -> Ptr (C a) -> CInt -> CInt -> IO CString

inverse :: forall a. Code (C a) => Ptr (C a) -> CInt -> CInt -> Ptr (C a) -> CInt -> CInt -> IO CString

c_adjoint :: CInt -> Ptr (C a) -> CInt -> CInt -> Ptr (C a) -> CInt -> CInt -> IO CString

adjoint :: forall a. Code (C a) => Ptr (C a) -> CInt -> CInt -> Ptr (C a) -> CInt -> CInt -> IO CString

c_conjugate :: CInt -> Ptr (C a) -> CInt -> CInt -> Ptr (C a) -> CInt -> CInt -> IO CString

c_normalize :: CInt -> Ptr (C a) -> CInt -> CInt -> IO CString

conjugate :: forall a. Code (C a) => Ptr (C a) -> CInt -> CInt -> Ptr (C a) -> CInt -> CInt -> IO CString

normalize :: forall a. Code (C a) => Ptr (C a) -> CInt -> CInt -> IO CString

c_sum :: CInt -> Ptr (C a) -> Ptr (C a) -> CInt -> CInt -> IO CString

sum :: forall a. Code (C a) => Ptr (C a) -> Ptr (C a) -> CInt -> CInt -> IO CString

c_prod :: CInt -> Ptr (C a) -> Ptr (C a) -> CInt -> CInt -> IO CString

prod :: forall a. Code (C a) => Ptr (C a) -> Ptr (C a) -> CInt -> CInt -> IO CString

c_mean :: CInt -> Ptr (C a) -> Ptr (C a) -> CInt -> CInt -> IO CString

mean :: forall a. Code (C a) => Ptr (C a) -> Ptr (C a) -> CInt -> CInt -> IO CString

c_norm :: CInt -> Ptr (C a) -> Ptr (C a) -> CInt -> CInt -> IO CString

norm :: forall a. Code (C a) => Ptr (C a) -> Ptr (C a) -> CInt -> CInt -> IO CString

c_trace :: CInt -> Ptr (C a) -> Ptr (C a) -> CInt -> CInt -> IO CString

trace :: forall a. Code (C a) => Ptr (C a) -> Ptr (C a) -> CInt -> CInt -> IO CString

c_squaredNorm :: CInt -> Ptr (C a) -> Ptr (C a) -> CInt -> CInt -> IO CString

squaredNorm :: forall a. Code (C a) => Ptr (C a) -> Ptr (C a) -> CInt -> CInt -> IO CString

c_blueNorm :: CInt -> Ptr (C a) -> Ptr (C a) -> CInt -> CInt -> IO CString

blueNorm :: forall a. Code (C a) => Ptr (C a) -> Ptr (C a) -> CInt -> CInt -> IO CString

c_hypotNorm :: CInt -> Ptr (C a) -> Ptr (C a) -> CInt -> CInt -> IO CString

hypotNorm :: forall a. Code (C a) => Ptr (C a) -> Ptr (C a) -> CInt -> CInt -> IO CString

c_determinant :: CInt -> Ptr (C a) -> Ptr (C a) -> CInt -> CInt -> IO CString

determinant :: forall a. Code (C a) => Ptr (C a) -> Ptr (C a) -> CInt -> CInt -> IO CString

c_rank :: CInt -> CInt -> Ptr CInt -> Ptr (C a) -> CInt -> CInt -> IO CString

rank :: forall a. Code (C a) => CInt -> Ptr CInt -> Ptr (C a) -> CInt -> CInt -> IO CString

c_image :: CInt -> CInt -> Ptr (Ptr (C a)) -> Ptr CInt -> Ptr CInt -> Ptr (C a) -> CInt -> CInt -> IO CString

image :: forall a. Code (C a) => CInt -> Ptr (Ptr (C a)) -> Ptr CInt -> Ptr CInt -> Ptr (C a) -> CInt -> CInt -> IO CString

c_kernel :: CInt -> CInt -> Ptr (Ptr (C a)) -> Ptr CInt -> Ptr CInt -> Ptr (C a) -> CInt -> CInt -> IO CString

kernel :: forall a. Code (C a) => CInt -> Ptr (Ptr (C a)) -> Ptr CInt -> Ptr CInt -> Ptr (C a) -> CInt -> CInt -> IO CString

c_solve :: CInt -> CInt -> Ptr (C a) -> CInt -> CInt -> Ptr (C a) -> CInt -> CInt -> Ptr (C a) -> CInt -> CInt -> IO CString

solve :: forall a. Code (C a) => CInt -> Ptr (C a) -> CInt -> CInt -> Ptr (C a) -> CInt -> CInt -> Ptr (C a) -> CInt -> CInt -> IO CString

c_relativeError :: CInt -> Ptr (C a) -> Ptr (C a) -> CInt -> CInt -> Ptr (C a) -> CInt -> CInt -> Ptr (C a) -> CInt -> CInt -> IO CString

relativeError :: forall a. Code (C a) => Ptr (C a) -> Ptr (C a) -> CInt -> CInt -> Ptr (C a) -> CInt -> CInt -> Ptr (C a) -> CInt -> CInt -> IO CString

c_sparse_new :: CInt -> CInt -> CInt -> Ptr (CSparseMatrixPtr a) -> IO CString

sparse_new :: forall a. Code (C a) => CInt -> CInt -> Ptr (CSparseMatrixPtr a) -> IO CString

c_sparse_clone :: CInt -> CSparseMatrixPtr a -> Ptr (CSparseMatrixPtr a) -> IO CString

sparse_clone :: forall a. Code (C a) => CSparseMatrixPtr a -> Ptr (CSparseMatrixPtr a) -> IO CString

c_sparse_fromList :: CInt -> CInt -> CInt -> Ptr (CTriplet a) -> CInt -> Ptr (CSparseMatrixPtr a) -> IO CString

sparse_fromList :: forall a. Code (C a) => CInt -> CInt -> Ptr (CTriplet a) -> CInt -> Ptr (CSparseMatrixPtr a) -> IO CString

c_sparse_toList :: CInt -> CSparseMatrixPtr a -> Ptr (CTriplet a) -> CInt -> IO CString

c_sparse_free :: CInt -> CSparseMatrixPtr a -> IO CString

sparse_toList :: forall a. Code (C a) => CSparseMatrixPtr a -> Ptr (CTriplet a) -> CInt -> IO CString

sparse_free :: forall a. Code (C a) => CSparseMatrixPtr a -> IO CString

c_sparse_makeCompressed :: CInt -> CSparseMatrixPtr a -> Ptr (CSparseMatrixPtr a) -> IO CString

sparse_makeCompressed :: forall a. Code (C a) => CSparseMatrixPtr a -> Ptr (CSparseMatrixPtr a) -> IO CString

c_sparse_uncompress :: CInt -> CSparseMatrixPtr a -> Ptr (CSparseMatrixPtr a) -> IO CString

sparse_uncompress :: forall a. Code (C a) => CSparseMatrixPtr a -> Ptr (CSparseMatrixPtr a) -> IO CString

c_sparse_isCompressed :: CInt -> CSparseMatrixPtr a -> Ptr CInt -> IO CString

sparse_isCompressed :: forall a. Code (C a) => CSparseMatrixPtr a -> Ptr CInt -> IO CString

c_sparse_transpose :: CInt -> CSparseMatrixPtr a -> Ptr (CSparseMatrixPtr a) -> IO CString

sparse_transpose :: forall a. Code (C a) => CSparseMatrixPtr a -> Ptr (CSparseMatrixPtr a) -> IO CString

c_sparse_adjoint :: CInt -> CSparseMatrixPtr a -> Ptr (CSparseMatrixPtr a) -> IO CString

sparse_adjoint :: forall a. Code (C a) => CSparseMatrixPtr a -> Ptr (CSparseMatrixPtr a) -> IO CString

c_sparse_pruned :: CInt -> CSparseMatrixPtr a -> Ptr (CSparseMatrixPtr a) -> IO CString

sparse_pruned :: forall a. Code (C a) => CSparseMatrixPtr a -> Ptr (CSparseMatrixPtr a) -> IO CString

c_sparse_prunedRef :: CInt -> CSparseMatrixPtr a -> Ptr (C a) -> Ptr (CSparseMatrixPtr a) -> IO CString

sparse_prunedRef :: forall a. Code (C a) => CSparseMatrixPtr a -> Ptr (C a) -> Ptr (CSparseMatrixPtr a) -> IO CString

c_sparse_scale :: CInt -> CSparseMatrixPtr a -> Ptr (C a) -> Ptr (CSparseMatrixPtr a) -> IO CString

sparse_scale :: forall a. Code (C a) => CSparseMatrixPtr a -> Ptr (C a) -> Ptr (CSparseMatrixPtr a) -> IO CString

c_sparse_nonZeros :: CInt -> CSparseMatrixPtr a -> Ptr CInt -> IO CString

sparse_nonZeros :: forall a. Code (C a) => CSparseMatrixPtr a -> Ptr CInt -> IO CString

c_sparse_innerSize :: CInt -> CSparseMatrixPtr a -> Ptr CInt -> IO CString

sparse_innerSize :: forall a. Code (C a) => CSparseMatrixPtr a -> Ptr CInt -> IO CString

c_sparse_outerSize :: CInt -> CSparseMatrixPtr a -> Ptr CInt -> IO CString

sparse_outerSize :: forall a. Code (C a) => CSparseMatrixPtr a -> Ptr CInt -> IO CString

c_sparse_coeff :: CInt -> CSparseMatrixPtr a -> CInt -> CInt -> Ptr (C a) -> IO CString

sparse_coeff :: forall a. Code (C a) => CSparseMatrixPtr a -> CInt -> CInt -> Ptr (C a) -> IO CString

c_sparse_coeffRef :: CInt -> CSparseMatrixPtr a -> CInt -> CInt -> Ptr (Ptr (C a)) -> IO CString

c_sparse_cols :: CInt -> CSparseMatrixPtr a -> Ptr CInt -> IO CString

sparse_coeffRef :: forall a. Code (C a) => CSparseMatrixPtr a -> CInt -> CInt -> Ptr (Ptr (C a)) -> IO CString

sparse_cols :: forall a. Code (C a) => CSparseMatrixPtr a -> Ptr CInt -> IO CString

c_sparse_rows :: CInt -> CSparseMatrixPtr a -> Ptr CInt -> IO CString

sparse_rows :: forall a. Code (C a) => CSparseMatrixPtr a -> Ptr CInt -> IO CString

c_sparse_norm :: CInt -> CSparseMatrixPtr a -> Ptr (C a) -> IO CString

sparse_norm :: forall a. Code (C a) => CSparseMatrixPtr a -> Ptr (C a) -> IO CString

c_sparse_squaredNorm :: CInt -> CSparseMatrixPtr a -> Ptr (C a) -> IO CString

sparse_squaredNorm :: forall a. Code (C a) => CSparseMatrixPtr a -> Ptr (C a) -> IO CString

c_sparse_blueNorm :: CInt -> CSparseMatrixPtr a -> Ptr (C a) -> IO CString

sparse_blueNorm :: forall a. Code (C a) => CSparseMatrixPtr a -> Ptr (C a) -> IO CString

c_sparse_add :: CInt -> CSparseMatrixPtr a -> CSparseMatrixPtr a -> Ptr (CSparseMatrixPtr a) -> IO CString

sparse_add :: forall a. Code (C a) => CSparseMatrixPtr a -> CSparseMatrixPtr a -> Ptr (CSparseMatrixPtr a) -> IO CString

c_sparse_sub :: CInt -> CSparseMatrixPtr a -> CSparseMatrixPtr a -> Ptr (CSparseMatrixPtr a) -> IO CString

sparse_sub :: forall a. Code (C a) => CSparseMatrixPtr a -> CSparseMatrixPtr a -> Ptr (CSparseMatrixPtr a) -> IO CString

c_sparse_mul :: CInt -> CSparseMatrixPtr a -> CSparseMatrixPtr a -> Ptr (CSparseMatrixPtr a) -> IO CString

sparse_mul :: forall a. Code (C a) => CSparseMatrixPtr a -> CSparseMatrixPtr a -> Ptr (CSparseMatrixPtr a) -> IO CString

c_sparse_block :: CInt -> CSparseMatrixPtr a -> CInt -> CInt -> CInt -> CInt -> Ptr (CSparseMatrixPtr a) -> IO CString

sparse_block :: forall a. Code (C a) => CSparseMatrixPtr a -> CInt -> CInt -> CInt -> CInt -> Ptr (CSparseMatrixPtr a) -> IO CString

c_sparse_fromMatrix :: CInt -> Ptr (C a) -> CInt -> CInt -> Ptr (CSparseMatrixPtr a) -> IO CString

sparse_fromMatrix :: forall a. Code (C a) => Ptr (C a) -> CInt -> CInt -> Ptr (CSparseMatrixPtr a) -> IO CString

c_sparse_toMatrix :: CInt -> CSparseMatrixPtr a -> Ptr (C a) -> CInt -> CInt -> IO CString

sparse_toMatrix :: forall a. Code (C a) => CSparseMatrixPtr a -> Ptr (C a) -> CInt -> CInt -> IO CString

c_sparse_values :: CInt -> CSparseMatrixPtr a -> Ptr CInt -> Ptr (Ptr (C a)) -> IO CString

sparse_values :: forall a. Code (C a) => CSparseMatrixPtr a -> Ptr CInt -> Ptr (Ptr (C a)) -> IO CString

c_sparse_outerStarts :: CInt -> CSparseMatrixPtr a -> Ptr CInt -> Ptr (Ptr CInt) -> IO CString

sparse_outerStarts :: forall a. Code (C a) => CSparseMatrixPtr a -> Ptr CInt -> Ptr (Ptr CInt) -> IO CString

c_sparse_innerIndices :: CInt -> CSparseMatrixPtr a -> Ptr CInt -> Ptr (Ptr CInt) -> IO CString

sparse_innerIndices :: forall a. Code (C a) => CSparseMatrixPtr a -> Ptr CInt -> Ptr (Ptr CInt) -> IO CString

c_sparse_innerNNZs :: CInt -> CSparseMatrixPtr a -> Ptr CInt -> Ptr (Ptr CInt) -> IO CString

c_sparse_setZero :: CInt -> CSparseMatrixPtr a -> IO CString

sparse_innerNNZs :: forall a. Code (C a) => CSparseMatrixPtr a -> Ptr CInt -> Ptr (Ptr CInt) -> IO CString

sparse_setZero :: forall a. Code (C a) => CSparseMatrixPtr a -> IO CString

c_sparse_setIdentity :: CInt -> CSparseMatrixPtr a -> IO CString

sparse_setIdentity :: forall a. Code (C a) => CSparseMatrixPtr a -> IO CString

c_sparse_reserve :: CInt -> CSparseMatrixPtr a -> CInt -> IO CString

sparse_reserve :: forall a. Code (C a) => CSparseMatrixPtr a -> CInt -> IO CString

c_sparse_resize :: CInt -> CSparseMatrixPtr a -> CInt -> CInt -> IO CString

sparse_resize :: forall a. Code (C a) => CSparseMatrixPtr a -> CInt -> CInt -> IO CString

c_sparse_conservativeResize :: CInt -> CSparseMatrixPtr a -> CInt -> CInt -> IO CString

sparse_conservativeResize :: forall a. Code (C a) => CSparseMatrixPtr a -> CInt -> CInt -> IO CString

c_sparse_compressInplace :: CInt -> CSparseMatrixPtr a -> IO CString

sparse_compressInplace :: forall a. Code (C a) => CSparseMatrixPtr a -> IO CString

c_sparse_uncompressInplace :: CInt -> CSparseMatrixPtr a -> IO CString

sparse_uncompressInplace :: forall a. Code (C a) => CSparseMatrixPtr a -> IO CString

c_sparse_la_newSolver :: CInt -> CInt -> Ptr (CSolverPtr a) -> IO CString

sparse_la_newSolver :: forall s a. (Code s, Code (C a)) => s -> Ptr (CSolverPtr a) -> IO CString

c_sparse_la_freeSolver :: CInt -> CInt -> CSolverPtr a -> IO CString

sparse_la_freeSolver :: forall s a. (Code s, Code (C a)) => s -> CSolverPtr a -> IO CString

c_sparse_la_factorize :: CInt -> CInt -> CSolverPtr a -> CSparseMatrixPtr a -> IO CString

sparse_la_factorize :: forall s a. (Code s, Code (C a)) => s -> CSolverPtr a -> CSparseMatrixPtr a -> IO CString

c_sparse_la_analyzePattern :: CInt -> CInt -> CSolverPtr a -> CSparseMatrixPtr a -> IO CString

sparse_la_analyzePattern :: forall s a. (Code s, Code (C a)) => s -> CSolverPtr a -> CSparseMatrixPtr a -> IO CString

c_sparse_la_compute :: CInt -> CInt -> CSolverPtr a -> CSparseMatrixPtr a -> IO CString

sparse_la_compute :: forall s a. (Code s, Code (C a)) => s -> CSolverPtr a -> CSparseMatrixPtr a -> IO CString

c_sparse_la_tolerance :: CInt -> CInt -> CSolverPtr a -> Ptr CDouble -> IO CString

sparse_la_tolerance :: forall s a. (Code s, Code (C a)) => s -> CSolverPtr a -> Ptr CDouble -> IO CString

c_sparse_la_setTolerance :: CInt -> CInt -> CSolverPtr a -> CDouble -> IO CString

sparse_la_setTolerance :: forall s a. (Code s, Code (C a)) => s -> CSolverPtr a -> CDouble -> IO CString

c_sparse_la_maxIterations :: CInt -> CInt -> CSolverPtr a -> Ptr CInt -> IO CString

sparse_la_maxIterations :: forall s a. (Code s, Code (C a)) => s -> CSolverPtr a -> Ptr CInt -> IO CString

c_sparse_la_setMaxIterations :: CInt -> CInt -> CSolverPtr a -> CInt -> IO CString

sparse_la_setMaxIterations :: forall s a. (Code s, Code (C a)) => s -> CSolverPtr a -> CInt -> IO CString

c_sparse_la_info :: CInt -> CInt -> CSolverPtr a -> Ptr CInt -> IO CString

sparse_la_info :: forall s a. (Code s, Code (C a)) => s -> CSolverPtr a -> Ptr CInt -> IO CString

c_sparse_la_error :: CInt -> CInt -> CSolverPtr a -> Ptr CDouble -> IO CString

sparse_la_error :: forall s a. (Code s, Code (C a)) => s -> CSolverPtr a -> Ptr CDouble -> IO CString

c_sparse_la_iterations :: CInt -> CInt -> CSolverPtr a -> Ptr CInt -> IO CString

sparse_la_iterations :: forall s a. (Code s, Code (C a)) => s -> CSolverPtr a -> Ptr CInt -> IO CString

c_sparse_la_solve :: CInt -> CInt -> CSolverPtr a -> CSparseMatrixPtr a -> Ptr (CSparseMatrixPtr a) -> IO CString

sparse_la_solve :: forall s a. (Code s, Code (C a)) => s -> CSolverPtr a -> CSparseMatrixPtr a -> Ptr (CSparseMatrixPtr a) -> IO CString

c_sparse_la_matrixQ :: CInt -> CInt -> CSolverPtr a -> Ptr (CSparseMatrixPtr a) -> IO CString

sparse_la_matrixQ :: forall s a. (Code s, Code (C a)) => s -> CSolverPtr a -> Ptr (CSparseMatrixPtr a) -> IO CString

c_sparse_la_matrixR :: CInt -> CInt -> CSolverPtr a -> Ptr (CSparseMatrixPtr a) -> IO CString

sparse_la_matrixR :: forall s a. (Code s, Code (C a)) => s -> CSolverPtr a -> Ptr (CSparseMatrixPtr a) -> IO CString

c_sparse_la_setPivotThreshold :: CInt -> CInt -> CSolverPtr a -> CDouble -> IO CString

sparse_la_setPivotThreshold :: forall s a. (Code s, Code (C a)) => s -> CSolverPtr a -> CDouble -> IO CString

c_sparse_la_rank :: CInt -> CInt -> CSolverPtr a -> Ptr CInt -> IO CString

sparse_la_rank :: forall s a. (Code s, Code (C a)) => s -> CSolverPtr a -> Ptr CInt -> IO CString

c_sparse_la_matrixL :: CInt -> CInt -> CSolverPtr a -> Ptr (CSparseMatrixPtr a) -> IO CString

sparse_la_matrixL :: forall s a. (Code s, Code (C a)) => s -> CSolverPtr a -> Ptr (CSparseMatrixPtr a) -> IO CString

c_sparse_la_matrixU :: CInt -> CInt -> CSolverPtr a -> Ptr (CSparseMatrixPtr a) -> IO CString

sparse_la_matrixU :: forall s a. (Code s, Code (C a)) => s -> CSolverPtr a -> Ptr (CSparseMatrixPtr a) -> IO CString

c_sparse_la_setSymmetric :: CInt -> CInt -> CSolverPtr a -> CInt -> IO CString

sparse_la_setSymmetric :: forall s a. (Code s, Code (C a)) => s -> CSolverPtr a -> CInt -> IO CString

c_sparse_la_determinant :: CInt -> CInt -> CSolverPtr a -> Ptr (C a) -> IO CString

sparse_la_determinant :: forall s a. (Code s, Code (C a)) => s -> CSolverPtr a -> Ptr (C a) -> IO CString

c_sparse_la_logAbsDeterminant :: CInt -> CInt -> CSolverPtr a -> Ptr (C a) -> IO CString

sparse_la_logAbsDeterminant :: forall s a. (Code s, Code (C a)) => s -> CSolverPtr a -> Ptr (C a) -> IO CString

c_sparse_la_absDeterminant :: CInt -> CInt -> CSolverPtr a -> Ptr (C a) -> IO CString

sparse_la_absDeterminant :: forall s a. (Code s, Code (C a)) => s -> CSolverPtr a -> Ptr (C a) -> IO CString

c_sparse_la_signDeterminant :: CInt -> CInt -> CSolverPtr a -> Ptr (C a) -> IO CString

sparse_la_signDeterminant :: forall s a. (Code s, Code (C a)) => s -> CSolverPtr a -> Ptr (C a) -> IO CString

Orphan instances

Storable a => Binary (Vector a)

Binary instance for Vector

Methods

put :: Vector a -> Put

get :: Get (Vector a)

putList :: [Vector a] -> Put