LinearSolver.hs

{-# OPTIONS_GHC -Wall #-}
{-# OPTIONS_GHC -fno-warn-unused-imports #-}
{-# OPTIONS_GHC -fno-warn-orphans #-}
{-# Language ForeignFunctionInterface #-}
{-# Language FlexibleInstances #-}
{-# Language MultiParamTypeClasses #-}

module Casadi.Wrappers.Classes.LinearSolver
       (
         LinearSolver,
         LinearSolverClass(..),
         linearSolver,
         linearSolver',
         linearSolver'',
         linearSolver_checkNode,
         linearSolver_prepare,
         linearSolver_prepared,
         linearSolver_solve,
         linearSolver_solve',
         linearSolver_solve'',
         linearSolver_solve''',
       ) where


import Prelude hiding ( Functor )

import Data.Vector ( Vector )
import Foreign.C.Types
import Foreign.Ptr ( Ptr )
import Foreign.ForeignPtr ( newForeignPtr )
import System.IO.Unsafe ( unsafePerformIO ) -- for show instances

import Casadi.Wrappers.Classes.PrintableObject
import Casadi.Wrappers.CToolsInstances ( )
import Casadi.Wrappers.Data
import Casadi.Wrappers.Enums
import Casadi.MarshalTypes ( CppVec, StdString' ) -- StdOstream'
import Casadi.Marshal ( Marshal(..), withMarshal )
import Casadi.WrapReturn ( WrapReturn(..) )

instance Show LinearSolver where
  show = unsafePerformIO . printableObject_getDescription
-- direct wrapper
foreign import ccall unsafe "CasADi__LinearSolver__prepare" c_CasADi__LinearSolver__prepare
  :: Ptr LinearSolver' -> IO ()
casADi__LinearSolver__prepare
  :: LinearSolver -> IO ()
casADi__LinearSolver__prepare x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__LinearSolver__prepare x0' >>= wrapReturn

-- classy wrapper
{-|
>Factorize the matrix.
-}
linearSolver_prepare :: LinearSolverClass a => a -> IO ()
linearSolver_prepare x = casADi__LinearSolver__prepare (castLinearSolver x)


-- direct wrapper
foreign import ccall unsafe "CasADi__LinearSolver__solve" c_CasADi__LinearSolver__solve
  :: Ptr LinearSolver' -> CInt -> IO ()
casADi__LinearSolver__solve
  :: LinearSolver -> Bool -> IO ()
casADi__LinearSolver__solve x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__LinearSolver__solve x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>>  void CasADi::LinearSolver::solve(bool transpose=false)
>------------------------------------------------------------------------
>
>Solve the system of equations, internal vector.
>
>>  void CasADi::LinearSolver::solve(double *x, int nrhs=1, bool transpose=false)
>------------------------------------------------------------------------
>[INTERNAL] 
> Solve the factorized system of equations.
>
>>  MX CasADi::LinearSolver::solve(const MX &A, const MX &B, bool transpose=false)
>------------------------------------------------------------------------
>
>Create a solve node.
>
>>  void CasADi::Function::solve()
>------------------------------------------------------------------------
>
>the same as evaluate()
-}
linearSolver_solve :: LinearSolverClass a => a -> Bool -> IO ()
linearSolver_solve x = casADi__LinearSolver__solve (castLinearSolver x)


-- direct wrapper
foreign import ccall unsafe "CasADi__LinearSolver__solve_TIC" c_CasADi__LinearSolver__solve_TIC
  :: Ptr LinearSolver' -> IO ()
casADi__LinearSolver__solve'
  :: LinearSolver -> IO ()
casADi__LinearSolver__solve' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__LinearSolver__solve_TIC x0' >>= wrapReturn

-- classy wrapper
linearSolver_solve' :: LinearSolverClass a => a -> IO ()
linearSolver_solve' x = casADi__LinearSolver__solve' (castLinearSolver x)


-- direct wrapper
foreign import ccall unsafe "CasADi__LinearSolver__solve_TIC_TIC" c_CasADi__LinearSolver__solve_TIC_TIC
  :: Ptr LinearSolver' -> Ptr MX' -> Ptr MX' -> CInt -> IO (Ptr MX')
casADi__LinearSolver__solve''
  :: LinearSolver -> MX -> MX -> Bool -> IO MX
casADi__LinearSolver__solve'' x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  c_CasADi__LinearSolver__solve_TIC_TIC x0' x1' x2' x3' >>= wrapReturn

-- classy wrapper
linearSolver_solve'' :: LinearSolverClass a => a -> MX -> MX -> Bool -> IO MX
linearSolver_solve'' x = casADi__LinearSolver__solve'' (castLinearSolver x)


-- direct wrapper
foreign import ccall unsafe "CasADi__LinearSolver__solve_TIC_TIC_TIC" c_CasADi__LinearSolver__solve_TIC_TIC_TIC
  :: Ptr LinearSolver' -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
casADi__LinearSolver__solve'''
  :: LinearSolver -> MX -> MX -> IO MX
casADi__LinearSolver__solve''' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__LinearSolver__solve_TIC_TIC_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
linearSolver_solve''' :: LinearSolverClass a => a -> MX -> MX -> IO MX
linearSolver_solve''' x = casADi__LinearSolver__solve''' (castLinearSolver x)


-- direct wrapper
foreign import ccall unsafe "CasADi__LinearSolver__prepared" c_CasADi__LinearSolver__prepared
  :: Ptr LinearSolver' -> IO CInt
casADi__LinearSolver__prepared
  :: LinearSolver -> IO Bool
casADi__LinearSolver__prepared x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__LinearSolver__prepared x0' >>= wrapReturn

-- classy wrapper
{-|
>Check if prepared.
-}
linearSolver_prepared :: LinearSolverClass a => a -> IO Bool
linearSolver_prepared x = casADi__LinearSolver__prepared (castLinearSolver x)


-- direct wrapper
foreign import ccall unsafe "CasADi__LinearSolver__checkNode" c_CasADi__LinearSolver__checkNode
  :: Ptr LinearSolver' -> IO CInt
casADi__LinearSolver__checkNode
  :: LinearSolver -> IO Bool
casADi__LinearSolver__checkNode x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__LinearSolver__checkNode x0' >>= wrapReturn

-- classy wrapper
{-|
>Check if the node is pointing to the right type of object.
-}
linearSolver_checkNode :: LinearSolverClass a => a -> IO Bool
linearSolver_checkNode x = casADi__LinearSolver__checkNode (castLinearSolver x)


-- direct wrapper
foreign import ccall unsafe "CasADi__LinearSolver__LinearSolver" c_CasADi__LinearSolver__LinearSolver
  :: IO (Ptr LinearSolver')
casADi__LinearSolver__LinearSolver
  :: IO LinearSolver
casADi__LinearSolver__LinearSolver  =
  c_CasADi__LinearSolver__LinearSolver  >>= wrapReturn

-- classy wrapper
{-|
>>  CasADi::LinearSolver::LinearSolver()
>------------------------------------------------------------------------
>[INTERNAL] 
>Default (empty) constructor
>
>>  CasADi::LinearSolver::LinearSolver(const Sparsity &sp, int nrhs=1)
>------------------------------------------------------------------------
>
>Create a linear solver given a sparsity pattern (creates a dummy solver
>only)
-}
linearSolver :: IO LinearSolver
linearSolver = casADi__LinearSolver__LinearSolver


-- direct wrapper
foreign import ccall unsafe "CasADi__LinearSolver__LinearSolver_TIC" c_CasADi__LinearSolver__LinearSolver_TIC
  :: Ptr Sparsity' -> CInt -> IO (Ptr LinearSolver')
casADi__LinearSolver__LinearSolver'
  :: Sparsity -> Int -> IO LinearSolver
casADi__LinearSolver__LinearSolver' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__LinearSolver__LinearSolver_TIC x0' x1' >>= wrapReturn

-- classy wrapper
linearSolver' :: Sparsity -> Int -> IO LinearSolver
linearSolver' = casADi__LinearSolver__LinearSolver'


-- direct wrapper
foreign import ccall unsafe "CasADi__LinearSolver__LinearSolver_TIC_TIC" c_CasADi__LinearSolver__LinearSolver_TIC_TIC
  :: Ptr Sparsity' -> IO (Ptr LinearSolver')
casADi__LinearSolver__LinearSolver''
  :: Sparsity -> IO LinearSolver
casADi__LinearSolver__LinearSolver'' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__LinearSolver__LinearSolver_TIC_TIC x0' >>= wrapReturn

-- classy wrapper
linearSolver'' :: Sparsity -> IO LinearSolver
linearSolver'' = casADi__LinearSolver__LinearSolver''