{-# LINE 1 "src/Eigen/Internal.hsc" #-}
--------------------------------------------------------------------------------

{-# OPTIONS_GHC -fno-warn-orphans #-}

--------------------------------------------------------------------------------

{-# LANGUAGE AllowAmbiguousTypes       #-}
{-# LANGUAGE BangPatterns              #-}
{-# LANGUAGE CPP                       #-}
{-# LANGUAGE EmptyDataDecls            #-}
{-# LANGUAGE FlexibleContexts          #-}
{-# LANGUAGE FlexibleInstances         #-}
{-# LANGUAGE ForeignFunctionInterface  #-}
{-# LANGUAGE FunctionalDependencies    #-}
{-# LANGUAGE GADTs                     #-}
{-# LANGUAGE KindSignatures            #-}
{-# LANGUAGE LambdaCase                #-}
{-# LANGUAGE MagicHash                 #-}
{-# LANGUAGE MultiParamTypeClasses     #-}
{-# LANGUAGE Rank2Types                #-}
{-# LANGUAGE ScopedTypeVariables       #-}
{-# LANGUAGE StandaloneDeriving        #-}
{-# LANGUAGE TypeApplications          #-}
{-# LANGUAGE TypeFamilyDependencies    #-}
{-# LANGUAGE TypeInType                #-}
{-# LANGUAGE UnboxedTuples             #-}
{-# LANGUAGE UndecidableInstances      #-}

--------------------------------------------------------------------------------

-- | Internal module to Eigen.
--   Here we define all foreign function calls,
--   and some typeclasses integral to the public and private interfaces
--   of the library.
module Eigen.Internal where --   FIXME: Explicit export list

--------------------------------------------------------------------------------

import           Control.Monad            (when)
import           Data.Binary              (Binary(put,get))
import           Data.Binary.Get          (getByteString, getWord32be)
import           Data.Binary.Put          (putByteString, putWord32be)
import           Data.Bits                (xor)
import           Data.Complex             (Complex((:+)))
import           Data.Kind                (Type)
import           Data.Proxy               (Proxy(Proxy))
import           Foreign.C.String         (CString, peekCString)
import           Foreign.C.Types          (CInt(CInt), CFloat(CFloat), CDouble(CDouble), CChar)
import           Foreign.ForeignPtr       (ForeignPtr, castForeignPtr, withForeignPtr)
import           Foreign.Ptr              (Ptr, castPtr, nullPtr, plusPtr)
import           Foreign.Storable         (Storable(sizeOf, alignment, poke, peek, peekByteOff, peekElemOff, pokeByteOff, pokeElemOff))
import           GHC.TypeLits             (natVal, KnownNat, Nat)
import           System.IO.Unsafe         (unsafeDupablePerformIO)
import qualified Data.Vector.Storable     as VS
import qualified Data.ByteString          as BS
import qualified Data.ByteString.Internal as BSI

--------------------------------------------------------------------------------

-- | Like 'Proxy', but specialised to 'Nat'.
data Row (r :: Nat) = Row
-- | Like 'Proxy', but specialised to 'Nat'.
data Col (c :: Nat) = Col

-- | Used internally. Given a 'KnownNat' constraint, turn the type-level 'Nat' into an 'Int'.
natToInt :: forall n. KnownNat n => Int
{-# INLINE natToInt #-}
natToInt = fromIntegral (natVal @n Proxy)

--------------------------------------------------------------------------------

-- | 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.
class Cast (a :: Type) where
  type family C a = (result :: Type) | result -> a
  toC   :: a -> C a
  fromC :: C a -> a

instance Cast Int where
  type C Int = CInt
  toC = CInt . fromIntegral
  {-# INLINE toC #-}
  fromC (CInt x) = fromIntegral x
  {-# INLINE fromC #-}

instance Cast Float where
  type C Float = CFloat
  toC = CFloat
  {-# INLINE toC #-}
  fromC (CFloat x) = x
  {-# INLINE fromC #-}

instance Cast Double where
  type C Double = CDouble
  toC = CDouble
  {-# INLINE toC #-}
  fromC (CDouble x) = x
  {-# INLINE fromC #-}

instance Cast a => Cast (Complex a) where
  type C (Complex a) = CComplex (C a)
  toC (a :+ b) = CComplex (toC a) (toC b)
  {-# INLINE toC #-}
  fromC (CComplex a b) = (fromC a) :+ (fromC b)
  {-# INLINE fromC #-}

-- | WARNING! 'toC' is lossy for any Int greater than (maxBound :: Int32)!
instance Cast a => Cast (Int, Int, a) where
  type C (Int, Int, a) = CTriplet a
  {-# INLINE toC #-}
  toC (x, y, z) = CTriplet (toC x) (toC y) (toC z)
  {-# INLINE fromC #-}
  fromC (CTriplet x y z) = (fromC x, fromC y, fromC z)

--------------------------------------------------------------------------------

-- | Complex number for FFI with the same memory layout as std::complex\<T\>
data CComplex a = CComplex !a !a deriving (Show)

instance Storable a => Storable (CComplex a) where
    sizeOf _ = sizeOf (undefined :: a) * 2
    alignment _ = alignment (undefined :: a)
    poke p (CComplex x y) = do
        pokeElemOff (castPtr p) 0 x
        pokeElemOff (castPtr p) 1 y
    peek p = CComplex
        <$> peekElemOff (castPtr p) 0
        <*> peekElemOff (castPtr p) 1

--------------------------------------------------------------------------------

-- | FIXME: Doc
data CTriplet a where
  CTriplet :: Cast a => !CInt -> !CInt -> !(C a) -> CTriplet a

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

instance (Storable a, Elem a) => Storable (CTriplet a) where
    sizeOf _ = sizeOf (undefined :: a) + sizeOf (undefined :: CInt) * 2
    alignment _ = alignment (undefined :: CInt)
    poke p (CTriplet row col val) = do
        pokeElemOff (castPtr p) 0 row
        pokeElemOff (castPtr p) 1 col
        pokeByteOff p (sizeOf (undefined :: CInt) * 2) val
    peek p = CTriplet
        <$> peekElemOff (castPtr p) 0
        <*> peekElemOff (castPtr p) 1
        <*> peekByteOff p (sizeOf (undefined :: CInt) * 2)

--------------------------------------------------------------------------------

-- | `Elem` is a closed typeclass that encompasses the properties
--   eigen expects its values to possess, and simplifies the external
--   API quite a bit.
class (Num a, Cast a, Storable a, Storable (C a), Code (C a)) => Elem a

instance Elem Float
instance Elem Double
instance Elem (Complex Float)
instance Elem (Complex Double)

--------------------------------------------------------------------------------

-- | Encode a C Type as a CInt
--
--   Hack used in FFI wrapper functions when constructing FFI calls
class Code a where; code :: a -> CInt
instance Code CFloat             where; code _ = 0
instance Code CDouble            where; code _ = 1
instance Code (CComplex CFloat)  where; code _ = 2
instance Code (CComplex CDouble) where; code _ = 3

-- | Hack used in constructing FFI calls.
newtype MagicCode = MagicCode CInt deriving Eq

instance Binary MagicCode where
    put (MagicCode _code) = putWord32be $ fromIntegral _code
    get = MagicCode . fromIntegral <$> getWord32be

-- | Hack used in constructing FFI calls.
magicCode :: Code a => a -> MagicCode
magicCode x = MagicCode (code x `xor` 0x45696730)

--------------------------------------------------------------------------------

-- | Machine size of a 'CInt'.
intSize :: Int
intSize = sizeOf (undefined :: CInt)

-- | FIXME: Doc
encodeInt :: CInt -> BS.ByteString
encodeInt x = BSI.unsafeCreate (sizeOf x) $ (`poke` x) . castPtr

-- | FIXME: Doc
decodeInt :: BS.ByteString -> CInt
decodeInt (BSI.PS fp fo fs)
    | fs == sizeOf x = x
    | otherwise = error "decodeInt: wrong buffer size"
    where x = performIO $ withForeignPtr fp $ peek . (`plusPtr` fo)

--------------------------------------------------------------------------------

-- | 'Binary' instance for 'Data.Vector.Storable.Mutable.Vector'
instance Storable a => Binary (VS.Vector a) where
    put vs = put (BS.length bs) >> putByteString bs where
        (fp,fs) = VS.unsafeToForeignPtr0 vs
        es = sizeOf (VS.head vs)
        bs = BSI.fromForeignPtr (castForeignPtr fp) 0 (fs * es)

    get = get >>= getByteString >>= \bs -> let
        (fp,fo,fs) = BSI.toForeignPtr bs
        es = sizeOf (VS.head vs)
        -- `plusForeignPtr` is used qualified here to just remind a reader
        -- that it is defined internally within eigen
        vs = VS.unsafeFromForeignPtr0 (Eigen.Internal.plusForeignPtr fp fo) (fs `div` es)
        in return vs

--------------------------------------------------------------------------------

-- | 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)

-- {-# INLINE unholyPerformIO #-}
-- unholyPerformIO :: IO a -> a
-- unholyPerformIO (IO m) = case m realWorld# of (# _, r #) -> r

-- | FIXME: replace with unholyPerformIO (?)
performIO :: IO a -> a
performIO = unsafeDupablePerformIO

-- | FIXME: Doc
plusForeignPtr :: ForeignPtr a -> Int -> ForeignPtr b
plusForeignPtr fp fo = castForeignPtr fp1 where
    vs :: VS.Vector CChar
    vs = VS.unsafeFromForeignPtr (castForeignPtr fp) fo 0
    (fp1, _) = VS.unsafeToForeignPtr0 vs

foreign import ccall "eigen-proxy.h free" c_freeString :: CString -> IO ()

call :: IO CString -> IO ()
call func = func >>= \c_str -> when (c_str /= nullPtr) $
    peekCString c_str >>= \str -> c_freeString c_str >> fail str

foreign import ccall "eigen-proxy.h free" free :: Ptr a -> IO ()

foreign import ccall "eigen-proxy.h eigen_setNbThreads" c_setNbThreads :: CInt -> IO ()
foreign import ccall "eigen-proxy.h eigen_getNbThreads" c_getNbThreads :: IO CInt

--------------------------------------------------------------------------------



foreign import ccall "eigen_random" c_random :: CInt -> Ptr (C a) -> CInt -> CInt -> IO CString
random :: forall a . Code (C a) => Ptr (C a) -> CInt -> CInt -> IO CString
random = c_random (code (undefined :: (C a)))
{-# LINE 268 "src/Eigen/Internal.hsc" #-}
foreign import ccall "eigen_identity" c_identity :: CInt -> Ptr (C a) -> CInt -> CInt -> IO CString
identity :: forall a . Code (C a) => Ptr (C a) -> CInt -> CInt -> IO CString
identity = c_identity (code (undefined :: (C a)))
{-# LINE 269 "src/Eigen/Internal.hsc" #-}
foreign import ccall "eigen_add" 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
add = c_add (code (undefined :: (C a)))
{-# LINE 270 "src/Eigen/Internal.hsc" #-}
foreign import ccall "eigen_sub" 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
sub = c_sub (code (undefined :: (C a)))
{-# LINE 271 "src/Eigen/Internal.hsc" #-}
foreign import ccall "eigen_mul" c_mul :: CInt -> Ptr (C a) -> CInt -> 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
mul = c_mul (code (undefined :: (C a)))
{-# LINE 272 "src/Eigen/Internal.hsc" #-}
foreign import ccall "eigen_diagonal" c_diagonal :: 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
diagonal = c_diagonal (code (undefined :: (C a)))
{-# LINE 273 "src/Eigen/Internal.hsc" #-}
foreign import ccall "eigen_transpose" 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
transpose = c_transpose (code (undefined :: (C a)))
{-# LINE 274 "src/Eigen/Internal.hsc" #-}
foreign import ccall "eigen_inverse" 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
inverse = c_inverse (code (undefined :: (C a)))
{-# LINE 275 "src/Eigen/Internal.hsc" #-}
foreign import ccall "eigen_adjoint" 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
adjoint = c_adjoint (code (undefined :: (C a)))
{-# LINE 276 "src/Eigen/Internal.hsc" #-}
foreign import ccall "eigen_conjugate" c_conjugate :: CInt -> Ptr (C a) -> CInt -> 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
conjugate = c_conjugate (code (undefined :: (C a)))
{-# LINE 277 "src/Eigen/Internal.hsc" #-}
foreign import ccall "eigen_normalize" c_normalize :: CInt -> Ptr (C a) -> CInt -> CInt -> IO CString
normalize :: forall a . Code (C a) => Ptr (C a) -> CInt -> CInt -> IO CString
normalize = c_normalize (code (undefined :: (C a)))
{-# LINE 278 "src/Eigen/Internal.hsc" #-}
foreign import ccall "eigen_sum" 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
sum = c_sum (code (undefined :: (C a)))
{-# LINE 279 "src/Eigen/Internal.hsc" #-}
foreign import ccall "eigen_prod" 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
prod = c_prod (code (undefined :: (C a)))
{-# LINE 280 "src/Eigen/Internal.hsc" #-}
foreign import ccall "eigen_mean" 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
mean = c_mean (code (undefined :: (C a)))
{-# LINE 281 "src/Eigen/Internal.hsc" #-}
foreign import ccall "eigen_norm" 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
norm = c_norm (code (undefined :: (C a)))
{-# LINE 282 "src/Eigen/Internal.hsc" #-}
foreign import ccall "eigen_trace" 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
trace = c_trace (code (undefined :: (C a)))
{-# LINE 283 "src/Eigen/Internal.hsc" #-}
foreign import ccall "eigen_squaredNorm" 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
squaredNorm = c_squaredNorm (code (undefined :: (C a)))
{-# LINE 284 "src/Eigen/Internal.hsc" #-}
foreign import ccall "eigen_blueNorm" 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
blueNorm = c_blueNorm (code (undefined :: (C a)))
{-# LINE 285 "src/Eigen/Internal.hsc" #-}
foreign import ccall "eigen_hypotNorm" 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
hypotNorm = c_hypotNorm (code (undefined :: (C a)))
{-# LINE 286 "src/Eigen/Internal.hsc" #-}
foreign import ccall "eigen_determinant" 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
determinant = c_determinant (code (undefined :: (C a)))
{-# LINE 287 "src/Eigen/Internal.hsc" #-}
foreign import ccall "eigen_rank" 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
rank = c_rank (code (undefined :: (C a)))
{-# LINE 288 "src/Eigen/Internal.hsc" #-}
foreign import ccall "eigen_image" 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
image = c_image (code (undefined :: (C a)))
{-# LINE 289 "src/Eigen/Internal.hsc" #-}
foreign import ccall "eigen_kernel" 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
kernel = c_kernel (code (undefined :: (C a)))
{-# LINE 290 "src/Eigen/Internal.hsc" #-}
foreign import ccall "eigen_solve" 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
solve = c_solve (code (undefined :: (C a)))
{-# LINE 291 "src/Eigen/Internal.hsc" #-}
foreign import ccall "eigen_relativeError" 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
relativeError = c_relativeError (code (undefined :: (C a)))
{-# LINE 292 "src/Eigen/Internal.hsc" #-}

--------------------------------------------------------------------------------



foreign import ccall "eigen_sparse_new" 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
sparse_new = c_sparse_new (code (undefined :: (C a)))
{-# LINE 298 "src/Eigen/Internal.hsc" #-}
foreign import ccall "eigen_sparse_clone" 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
sparse_clone = c_sparse_clone (code (undefined :: (C a)))
{-# LINE 299 "src/Eigen/Internal.hsc" #-}
foreign import ccall "eigen_sparse_fromList" 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
sparse_fromList = c_sparse_fromList (code (undefined :: (C a)))
{-# LINE 300 "src/Eigen/Internal.hsc" #-}
foreign import ccall "eigen_sparse_toList" c_sparse_toList :: CInt -> CSparseMatrixPtr a -> Ptr (CTriplet a) -> CInt -> IO CString
sparse_toList :: forall a . Code (C a) => CSparseMatrixPtr a -> Ptr (CTriplet a) -> CInt -> IO CString
sparse_toList = c_sparse_toList (code (undefined :: (C a)))
{-# LINE 301 "src/Eigen/Internal.hsc" #-}
foreign import ccall "eigen_sparse_free" c_sparse_free :: CInt -> CSparseMatrixPtr a -> IO CString
sparse_free :: forall a . Code (C a) => CSparseMatrixPtr a -> IO CString
sparse_free = c_sparse_free (code (undefined :: (C a)))
{-# LINE 302 "src/Eigen/Internal.hsc" #-}
foreign import ccall "eigen_sparse_makeCompressed" 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
sparse_makeCompressed = c_sparse_makeCompressed (code (undefined :: (C a)))
{-# LINE 303 "src/Eigen/Internal.hsc" #-}
foreign import ccall "eigen_sparse_uncompress" 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
sparse_uncompress = c_sparse_uncompress (code (undefined :: (C a)))
{-# LINE 304 "src/Eigen/Internal.hsc" #-}
foreign import ccall "eigen_sparse_isCompressed" c_sparse_isCompressed :: CInt -> CSparseMatrixPtr a -> Ptr CInt -> IO CString
sparse_isCompressed :: forall a . Code (C a) => CSparseMatrixPtr a -> Ptr CInt -> IO CString
sparse_isCompressed = c_sparse_isCompressed (code (undefined :: (C a)))
{-# LINE 305 "src/Eigen/Internal.hsc" #-}
foreign import ccall "eigen_sparse_transpose" 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
sparse_transpose = c_sparse_transpose (code (undefined :: (C a)))
{-# LINE 306 "src/Eigen/Internal.hsc" #-}
foreign import ccall "eigen_sparse_adjoint" 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
sparse_adjoint = c_sparse_adjoint (code (undefined :: (C a)))
{-# LINE 307 "src/Eigen/Internal.hsc" #-}
foreign import ccall "eigen_sparse_pruned" 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
sparse_pruned = c_sparse_pruned (code (undefined :: (C a)))
{-# LINE 308 "src/Eigen/Internal.hsc" #-}
foreign import ccall "eigen_sparse_prunedRef" 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
sparse_prunedRef = c_sparse_prunedRef (code (undefined :: (C a)))
{-# LINE 309 "src/Eigen/Internal.hsc" #-}
foreign import ccall "eigen_sparse_scale" 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
sparse_scale = c_sparse_scale (code (undefined :: (C a)))
{-# LINE 310 "src/Eigen/Internal.hsc" #-}
foreign import ccall "eigen_sparse_nonZeros" c_sparse_nonZeros :: CInt -> CSparseMatrixPtr a -> Ptr CInt -> IO CString
sparse_nonZeros :: forall a . Code (C a) => CSparseMatrixPtr a -> Ptr CInt -> IO CString
sparse_nonZeros = c_sparse_nonZeros (code (undefined :: (C a)))
{-# LINE 311 "src/Eigen/Internal.hsc" #-}
foreign import ccall "eigen_sparse_innerSize" c_sparse_innerSize :: CInt -> CSparseMatrixPtr a -> Ptr CInt -> IO CString
sparse_innerSize :: forall a . Code (C a) => CSparseMatrixPtr a -> Ptr CInt -> IO CString
sparse_innerSize = c_sparse_innerSize (code (undefined :: (C a)))
{-# LINE 312 "src/Eigen/Internal.hsc" #-}
foreign import ccall "eigen_sparse_outerSize" c_sparse_outerSize :: CInt -> CSparseMatrixPtr a -> Ptr CInt -> IO CString
sparse_outerSize :: forall a . Code (C a) => CSparseMatrixPtr a -> Ptr CInt -> IO CString
sparse_outerSize = c_sparse_outerSize (code (undefined :: (C a)))
{-# LINE 313 "src/Eigen/Internal.hsc" #-}
foreign import ccall "eigen_sparse_coeff" 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
sparse_coeff = c_sparse_coeff (code (undefined :: (C a)))
{-# LINE 314 "src/Eigen/Internal.hsc" #-}
foreign import ccall "eigen_sparse_coeffRef" c_sparse_coeffRef :: CInt -> CSparseMatrixPtr a -> CInt -> CInt -> Ptr (Ptr (C a)) -> IO CString
sparse_coeffRef :: forall a . Code (C a) => CSparseMatrixPtr a -> CInt -> CInt -> Ptr (Ptr (C a)) -> IO CString
sparse_coeffRef = c_sparse_coeffRef (code (undefined :: (C a)))
{-# LINE 315 "src/Eigen/Internal.hsc" #-}
foreign import ccall "eigen_sparse_cols" c_sparse_cols :: CInt -> CSparseMatrixPtr a -> Ptr CInt -> IO CString
sparse_cols :: forall a . Code (C a) => CSparseMatrixPtr a -> Ptr CInt -> IO CString
sparse_cols = c_sparse_cols (code (undefined :: (C a)))
{-# LINE 316 "src/Eigen/Internal.hsc" #-}
foreign import ccall "eigen_sparse_rows" c_sparse_rows :: CInt -> CSparseMatrixPtr a -> Ptr CInt -> IO CString
sparse_rows :: forall a . Code (C a) => CSparseMatrixPtr a -> Ptr CInt -> IO CString
sparse_rows = c_sparse_rows (code (undefined :: (C a)))
{-# LINE 317 "src/Eigen/Internal.hsc" #-}
foreign import ccall "eigen_sparse_norm" 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
sparse_norm = c_sparse_norm (code (undefined :: (C a)))
{-# LINE 318 "src/Eigen/Internal.hsc" #-}
foreign import ccall "eigen_sparse_squaredNorm" 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
sparse_squaredNorm = c_sparse_squaredNorm (code (undefined :: (C a)))
{-# LINE 319 "src/Eigen/Internal.hsc" #-}
foreign import ccall "eigen_sparse_blueNorm" 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
sparse_blueNorm = c_sparse_blueNorm (code (undefined :: (C a)))
{-# LINE 320 "src/Eigen/Internal.hsc" #-}
foreign import ccall "eigen_sparse_add" 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
sparse_add = c_sparse_add (code (undefined :: (C a)))
{-# LINE 321 "src/Eigen/Internal.hsc" #-}
foreign import ccall "eigen_sparse_sub" 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
sparse_sub = c_sparse_sub (code (undefined :: (C a)))
{-# LINE 322 "src/Eigen/Internal.hsc" #-}
foreign import ccall "eigen_sparse_mul" 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
sparse_mul = c_sparse_mul (code (undefined :: (C a)))
{-# LINE 323 "src/Eigen/Internal.hsc" #-}
foreign import ccall "eigen_sparse_block" 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
sparse_block = c_sparse_block (code (undefined :: (C a)))
{-# LINE 324 "src/Eigen/Internal.hsc" #-}
foreign import ccall "eigen_sparse_fromMatrix" 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
sparse_fromMatrix = c_sparse_fromMatrix (code (undefined :: (C a)))
{-# LINE 325 "src/Eigen/Internal.hsc" #-}
foreign import ccall "eigen_sparse_toMatrix" 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
sparse_toMatrix = c_sparse_toMatrix (code (undefined :: (C a)))
{-# LINE 326 "src/Eigen/Internal.hsc" #-}
foreign import ccall "eigen_sparse_values" 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
sparse_values = c_sparse_values (code (undefined :: (C a)))
{-# LINE 327 "src/Eigen/Internal.hsc" #-}
foreign import ccall "eigen_sparse_outerStarts" 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
sparse_outerStarts = c_sparse_outerStarts (code (undefined :: (C a)))
{-# LINE 328 "src/Eigen/Internal.hsc" #-}
foreign import ccall "eigen_sparse_innerIndices" 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
sparse_innerIndices = c_sparse_innerIndices (code (undefined :: (C a)))
{-# LINE 329 "src/Eigen/Internal.hsc" #-}
foreign import ccall "eigen_sparse_innerNNZs" c_sparse_innerNNZs :: CInt -> CSparseMatrixPtr a -> Ptr CInt -> Ptr (Ptr CInt) -> IO CString
sparse_innerNNZs :: forall a . Code (C a) => CSparseMatrixPtr a -> Ptr CInt -> Ptr (Ptr CInt) -> IO CString
sparse_innerNNZs = c_sparse_innerNNZs (code (undefined :: (C a)))
{-# LINE 330 "src/Eigen/Internal.hsc" #-}
foreign import ccall "eigen_sparse_setZero" c_sparse_setZero :: CInt -> CSparseMatrixPtr a -> IO CString
sparse_setZero :: forall a . Code (C a) => CSparseMatrixPtr a -> IO CString
sparse_setZero = c_sparse_setZero (code (undefined :: (C a)))
{-# LINE 331 "src/Eigen/Internal.hsc" #-}
foreign import ccall "eigen_sparse_setIdentity" c_sparse_setIdentity :: CInt -> CSparseMatrixPtr a -> IO CString
sparse_setIdentity :: forall a . Code (C a) => CSparseMatrixPtr a -> IO CString
sparse_setIdentity = c_sparse_setIdentity (code (undefined :: (C a)))
{-# LINE 332 "src/Eigen/Internal.hsc" #-}
foreign import ccall "eigen_sparse_reserve" c_sparse_reserve :: CInt -> CSparseMatrixPtr a -> CInt -> IO CString
sparse_reserve :: forall a . Code (C a) => CSparseMatrixPtr a -> CInt -> IO CString
sparse_reserve = c_sparse_reserve (code (undefined :: (C a)))
{-# LINE 333 "src/Eigen/Internal.hsc" #-}
foreign import ccall "eigen_sparse_resize" c_sparse_resize :: CInt -> CSparseMatrixPtr a -> CInt -> CInt -> IO CString
sparse_resize :: forall a . Code (C a) => CSparseMatrixPtr a -> CInt -> CInt -> IO CString
sparse_resize = c_sparse_resize (code (undefined :: (C a)))
{-# LINE 334 "src/Eigen/Internal.hsc" #-}

foreign import ccall "eigen_sparse_conservativeResize" c_sparse_conservativeResize :: CInt -> CSparseMatrixPtr a -> CInt -> CInt -> IO CString
sparse_conservativeResize :: forall a . Code (C a) => CSparseMatrixPtr a -> CInt -> CInt -> IO CString
sparse_conservativeResize = c_sparse_conservativeResize (code (undefined :: (C a)))
{-# LINE 336 "src/Eigen/Internal.hsc" #-}
foreign import ccall "eigen_sparse_compressInplace" c_sparse_compressInplace :: CInt -> CSparseMatrixPtr a -> IO CString
sparse_compressInplace :: forall a . Code (C a) => CSparseMatrixPtr a -> IO CString
sparse_compressInplace = c_sparse_compressInplace (code (undefined :: (C a)))
{-# LINE 337 "src/Eigen/Internal.hsc" #-}
foreign import ccall "eigen_sparse_uncompressInplace" c_sparse_uncompressInplace :: CInt -> CSparseMatrixPtr a -> IO CString
sparse_uncompressInplace :: forall a . Code (C a) => CSparseMatrixPtr a -> IO CString
sparse_uncompressInplace = c_sparse_uncompressInplace (code (undefined :: (C a)))
{-# LINE 338 "src/Eigen/Internal.hsc" #-}

--------------------------------------------------------------------------------



foreign import ccall "eigen_sparse_la_newSolver" 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
sparse_la_newSolver s = c_sparse_la_newSolver (code (undefined :: (C a))) (code s)
{-# LINE 344 "src/Eigen/Internal.hsc" #-}
foreign import ccall "eigen_sparse_la_freeSolver" 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
sparse_la_freeSolver s = c_sparse_la_freeSolver (code (undefined :: (C a))) (code s)
{-# LINE 345 "src/Eigen/Internal.hsc" #-}
foreign import ccall "eigen_sparse_la_factorize" 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
sparse_la_factorize s = c_sparse_la_factorize (code (undefined :: (C a))) (code s)
{-# LINE 346 "src/Eigen/Internal.hsc" #-}
foreign import ccall "eigen_sparse_la_analyzePattern" 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
sparse_la_analyzePattern s = c_sparse_la_analyzePattern (code (undefined :: (C a))) (code s)
{-# LINE 347 "src/Eigen/Internal.hsc" #-}
foreign import ccall "eigen_sparse_la_compute" 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
sparse_la_compute s = c_sparse_la_compute (code (undefined :: (C a))) (code s)
{-# LINE 348 "src/Eigen/Internal.hsc" #-}
foreign import ccall "eigen_sparse_la_tolerance" 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
sparse_la_tolerance s = c_sparse_la_tolerance (code (undefined :: (C a))) (code s)
{-# LINE 349 "src/Eigen/Internal.hsc" #-}
foreign import ccall "eigen_sparse_la_setTolerance" 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
sparse_la_setTolerance s = c_sparse_la_setTolerance (code (undefined :: (C a))) (code s)
{-# LINE 350 "src/Eigen/Internal.hsc" #-}
foreign import ccall "eigen_sparse_la_maxIterations" 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
sparse_la_maxIterations s = c_sparse_la_maxIterations (code (undefined :: (C a))) (code s)
{-# LINE 351 "src/Eigen/Internal.hsc" #-}
foreign import ccall "eigen_sparse_la_setMaxIterations" 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
sparse_la_setMaxIterations s = c_sparse_la_setMaxIterations (code (undefined :: (C a))) (code s)
{-# LINE 352 "src/Eigen/Internal.hsc" #-}
foreign import ccall "eigen_sparse_la_info" 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
sparse_la_info s = c_sparse_la_info (code (undefined :: (C a))) (code s)
{-# LINE 353 "src/Eigen/Internal.hsc" #-}
foreign import ccall "eigen_sparse_la_error" 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
sparse_la_error s = c_sparse_la_error (code (undefined :: (C a))) (code s)
{-# LINE 354 "src/Eigen/Internal.hsc" #-}
foreign import ccall "eigen_sparse_la_iterations" 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
sparse_la_iterations s = c_sparse_la_iterations (code (undefined :: (C a))) (code s)
{-# LINE 355 "src/Eigen/Internal.hsc" #-}
foreign import ccall "eigen_sparse_la_solve" 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
sparse_la_solve s = c_sparse_la_solve (code (undefined :: (C a))) (code s)
{-# LINE 356 "src/Eigen/Internal.hsc" #-}
-- #api3 sparse_la_solveWithGuess,     "CSolverPtr a -> CSparseMatrixPtr a -> CSparseMatrixPtr a -> Ptr (CSparseMatrixPtr a) -> IO CString"
foreign import ccall "eigen_sparse_la_matrixQ" 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
sparse_la_matrixQ s = c_sparse_la_matrixQ (code (undefined :: (C a))) (code s)
{-# LINE 358 "src/Eigen/Internal.hsc" #-}
foreign import ccall "eigen_sparse_la_matrixR" 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
sparse_la_matrixR s = c_sparse_la_matrixR (code (undefined :: (C a))) (code s)
{-# LINE 359 "src/Eigen/Internal.hsc" #-}
foreign import ccall "eigen_sparse_la_setPivotThreshold" 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
sparse_la_setPivotThreshold s = c_sparse_la_setPivotThreshold (code (undefined :: (C a))) (code s)
{-# LINE 360 "src/Eigen/Internal.hsc" #-}
foreign import ccall "eigen_sparse_la_rank" 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
sparse_la_rank s = c_sparse_la_rank (code (undefined :: (C a))) (code s)
{-# LINE 361 "src/Eigen/Internal.hsc" #-}
foreign import ccall "eigen_sparse_la_matrixL" 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
sparse_la_matrixL s = c_sparse_la_matrixL (code (undefined :: (C a))) (code s)
{-# LINE 362 "src/Eigen/Internal.hsc" #-}
foreign import ccall "eigen_sparse_la_matrixU" 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
sparse_la_matrixU s = c_sparse_la_matrixU (code (undefined :: (C a))) (code s)
{-# LINE 363 "src/Eigen/Internal.hsc" #-}
foreign import ccall "eigen_sparse_la_setSymmetric" 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
sparse_la_setSymmetric s = c_sparse_la_setSymmetric (code (undefined :: (C a))) (code s)
{-# LINE 364 "src/Eigen/Internal.hsc" #-}
foreign import ccall "eigen_sparse_la_determinant" 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
sparse_la_determinant s = c_sparse_la_determinant (code (undefined :: (C a))) (code s)
{-# LINE 365 "src/Eigen/Internal.hsc" #-}
foreign import ccall "eigen_sparse_la_logAbsDeterminant" 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
sparse_la_logAbsDeterminant s = c_sparse_la_logAbsDeterminant (code (undefined :: (C a))) (code s)
{-# LINE 366 "src/Eigen/Internal.hsc" #-}
foreign import ccall "eigen_sparse_la_absDeterminant" 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
sparse_la_absDeterminant s = c_sparse_la_absDeterminant (code (undefined :: (C a))) (code s)
{-# LINE 367 "src/Eigen/Internal.hsc" #-}
foreign import ccall "eigen_sparse_la_signDeterminant" 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
sparse_la_signDeterminant s = c_sparse_la_signDeterminant (code (undefined :: (C a))) (code s)
{-# LINE 368 "src/Eigen/Internal.hsc" #-}

--------------------------------------------------------------------------------