casadi-bindings-1.9.0.0: Casadi/Wrappers/Classes/SXFunction.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.SXFunction
       (
         SXFunction,
         SXFunctionClass(..),
         sxFunction,
         sxFunction',
         sxFunction'',
         sxFunction''',
         sxFunction_checkNode,
         sxFunction_clearSymbolic,
         sxFunction_countNodes,
         sxFunction_getAlgorithmSize,
         sxFunction_getAtomicInputReal,
         sxFunction_getAtomicOperation,
         sxFunction_getAtomicOutput,
         sxFunction_getFree,
         sxFunction_getWorkSize,
         sxFunction_grad,
         sxFunction_grad',
         sxFunction_grad'',
         sxFunction_grad''',
         sxFunction_grad'''',
         sxFunction_grad''''',
         sxFunction_grad'''''',
         sxFunction_hess,
         sxFunction_hess',
         sxFunction_hess'',
         sxFunction_hess''',
         sxFunction_hess'''',
         sxFunction_hess''''',
         sxFunction_hess'''''',
         sxFunction_jac,
         sxFunction_jac',
         sxFunction_jac'',
         sxFunction_jac''',
         sxFunction_jac'''',
         sxFunction_jac''''',
         sxFunction_jac'''''',
         sxFunction_jac''''''',
         sxFunction_jac'''''''',
         sxFunction_jac''''''''',
         sxFunction_jac'''''''''',
         sxFunction_jac''''''''''',
         sxFunction_jac'''''''''''',
         sxFunction_jac''''''''''''',
         sxFunction_jac'''''''''''''',
         sxFunction_tang,
         sxFunction_tang',
         sxFunction_tang'',
         sxFunction_tang''',
         sxFunction_tang'''',
         sxFunction_tang''''',
         sxFunction_tang'''''',
       ) 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 SXFunction where
  show = unsafePerformIO . printableObject_getDescription
-- direct wrapper
foreign import ccall unsafe "CasADi__SXFunction__jac" c_CasADi__SXFunction__jac
  :: Ptr SXFunction' -> CInt -> CInt -> CInt -> CInt -> IO (Ptr SX')
casADi__SXFunction__jac
  :: SXFunction -> Int -> Int -> Bool -> Bool -> IO SX
casADi__SXFunction__jac x0 x1 x2 x3 x4 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  c_CasADi__SXFunction__jac x0' x1' x2' x3' x4' >>= wrapReturn

-- classy wrapper
{-|
>Jacobian via source code transformation.
>
>See:  CasADi::Jacobian for an AD approach
-}
sxFunction_jac :: SXFunctionClass a => a -> Int -> Int -> Bool -> Bool -> IO SX
sxFunction_jac x = casADi__SXFunction__jac (castSXFunction x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXFunction__jac_TIC" c_CasADi__SXFunction__jac_TIC
  :: Ptr SXFunction' -> CInt -> CInt -> CInt -> IO (Ptr SX')
casADi__SXFunction__jac'
  :: SXFunction -> Int -> Int -> Bool -> IO SX
casADi__SXFunction__jac' x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  c_CasADi__SXFunction__jac_TIC x0' x1' x2' x3' >>= wrapReturn

-- classy wrapper
sxFunction_jac' :: SXFunctionClass a => a -> Int -> Int -> Bool -> IO SX
sxFunction_jac' x = casADi__SXFunction__jac' (castSXFunction x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXFunction__jac_TIC_TIC" c_CasADi__SXFunction__jac_TIC_TIC
  :: Ptr SXFunction' -> CInt -> CInt -> IO (Ptr SX')
casADi__SXFunction__jac''
  :: SXFunction -> Int -> Int -> IO SX
casADi__SXFunction__jac'' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__SXFunction__jac_TIC_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
sxFunction_jac'' :: SXFunctionClass a => a -> Int -> Int -> IO SX
sxFunction_jac'' x = casADi__SXFunction__jac'' (castSXFunction x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXFunction__jac_TIC_TIC_TIC" c_CasADi__SXFunction__jac_TIC_TIC_TIC
  :: Ptr SXFunction' -> CInt -> IO (Ptr SX')
casADi__SXFunction__jac'''
  :: SXFunction -> Int -> IO SX
casADi__SXFunction__jac''' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__SXFunction__jac_TIC_TIC_TIC x0' x1' >>= wrapReturn

-- classy wrapper
sxFunction_jac''' :: SXFunctionClass a => a -> Int -> IO SX
sxFunction_jac''' x = casADi__SXFunction__jac''' (castSXFunction x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXFunction__jac_TIC_TIC_TIC_TIC" c_CasADi__SXFunction__jac_TIC_TIC_TIC_TIC
  :: Ptr SXFunction' -> IO (Ptr SX')
casADi__SXFunction__jac''''
  :: SXFunction -> IO SX
casADi__SXFunction__jac'''' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SXFunction__jac_TIC_TIC_TIC_TIC x0' >>= wrapReturn

-- classy wrapper
sxFunction_jac'''' :: SXFunctionClass a => a -> IO SX
sxFunction_jac'''' x = casADi__SXFunction__jac'''' (castSXFunction x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXFunction__jac_TIC_TIC_TIC_TIC_TIC" c_CasADi__SXFunction__jac_TIC_TIC_TIC_TIC_TIC
  :: Ptr SXFunction' -> Ptr StdString' -> CInt -> CInt -> CInt -> IO (Ptr SX')
casADi__SXFunction__jac'''''
  :: SXFunction -> String -> Int -> Bool -> Bool -> IO SX
casADi__SXFunction__jac''''' x0 x1 x2 x3 x4 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  c_CasADi__SXFunction__jac_TIC_TIC_TIC_TIC_TIC x0' x1' x2' x3' x4' >>= wrapReturn

-- classy wrapper
sxFunction_jac''''' :: SXFunctionClass a => a -> String -> Int -> Bool -> Bool -> IO SX
sxFunction_jac''''' x = casADi__SXFunction__jac''''' (castSXFunction x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXFunction__jac_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__SXFunction__jac_TIC_TIC_TIC_TIC_TIC_TIC
  :: Ptr SXFunction' -> Ptr StdString' -> CInt -> CInt -> IO (Ptr SX')
casADi__SXFunction__jac''''''
  :: SXFunction -> String -> Int -> Bool -> IO SX
casADi__SXFunction__jac'''''' x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  c_CasADi__SXFunction__jac_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn

-- classy wrapper
sxFunction_jac'''''' :: SXFunctionClass a => a -> String -> Int -> Bool -> IO SX
sxFunction_jac'''''' x = casADi__SXFunction__jac'''''' (castSXFunction x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXFunction__jac_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__SXFunction__jac_TIC_TIC_TIC_TIC_TIC_TIC_TIC
  :: Ptr SXFunction' -> Ptr StdString' -> CInt -> IO (Ptr SX')
casADi__SXFunction__jac'''''''
  :: SXFunction -> String -> Int -> IO SX
casADi__SXFunction__jac''''''' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__SXFunction__jac_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
sxFunction_jac''''''' :: SXFunctionClass a => a -> String -> Int -> IO SX
sxFunction_jac''''''' x = casADi__SXFunction__jac''''''' (castSXFunction x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXFunction__jac_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__SXFunction__jac_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC
  :: Ptr SXFunction' -> Ptr StdString' -> IO (Ptr SX')
casADi__SXFunction__jac''''''''
  :: SXFunction -> String -> IO SX
casADi__SXFunction__jac'''''''' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__SXFunction__jac_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' >>= wrapReturn

-- classy wrapper
sxFunction_jac'''''''' :: SXFunctionClass a => a -> String -> IO SX
sxFunction_jac'''''''' x = casADi__SXFunction__jac'''''''' (castSXFunction x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXFunction__jac_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__SXFunction__jac_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC
  :: Ptr SXFunction' -> CInt -> Ptr StdString' -> CInt -> CInt -> IO (Ptr SX')
casADi__SXFunction__jac'''''''''
  :: SXFunction -> Int -> String -> Bool -> Bool -> IO SX
casADi__SXFunction__jac''''''''' x0 x1 x2 x3 x4 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  c_CasADi__SXFunction__jac_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' x3' x4' >>= wrapReturn

-- classy wrapper
sxFunction_jac''''''''' :: SXFunctionClass a => a -> Int -> String -> Bool -> Bool -> IO SX
sxFunction_jac''''''''' x = casADi__SXFunction__jac''''''''' (castSXFunction x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXFunction__jac_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__SXFunction__jac_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC
  :: Ptr SXFunction' -> CInt -> Ptr StdString' -> CInt -> IO (Ptr SX')
casADi__SXFunction__jac''''''''''
  :: SXFunction -> Int -> String -> Bool -> IO SX
casADi__SXFunction__jac'''''''''' x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  c_CasADi__SXFunction__jac_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn

-- classy wrapper
sxFunction_jac'''''''''' :: SXFunctionClass a => a -> Int -> String -> Bool -> IO SX
sxFunction_jac'''''''''' x = casADi__SXFunction__jac'''''''''' (castSXFunction x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXFunction__jac_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__SXFunction__jac_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC
  :: Ptr SXFunction' -> CInt -> Ptr StdString' -> IO (Ptr SX')
casADi__SXFunction__jac'''''''''''
  :: SXFunction -> Int -> String -> IO SX
casADi__SXFunction__jac''''''''''' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__SXFunction__jac_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
sxFunction_jac''''''''''' :: SXFunctionClass a => a -> Int -> String -> IO SX
sxFunction_jac''''''''''' x = casADi__SXFunction__jac''''''''''' (castSXFunction x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXFunction__jac_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__SXFunction__jac_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC
  :: Ptr SXFunction' -> Ptr StdString' -> Ptr StdString' -> CInt -> CInt -> IO (Ptr SX')
casADi__SXFunction__jac''''''''''''
  :: SXFunction -> String -> String -> Bool -> Bool -> IO SX
casADi__SXFunction__jac'''''''''''' x0 x1 x2 x3 x4 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  c_CasADi__SXFunction__jac_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' x3' x4' >>= wrapReturn

-- classy wrapper
sxFunction_jac'''''''''''' :: SXFunctionClass a => a -> String -> String -> Bool -> Bool -> IO SX
sxFunction_jac'''''''''''' x = casADi__SXFunction__jac'''''''''''' (castSXFunction x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXFunction__jac_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__SXFunction__jac_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC
  :: Ptr SXFunction' -> Ptr StdString' -> Ptr StdString' -> CInt -> IO (Ptr SX')
casADi__SXFunction__jac'''''''''''''
  :: SXFunction -> String -> String -> Bool -> IO SX
casADi__SXFunction__jac''''''''''''' x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  c_CasADi__SXFunction__jac_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn

-- classy wrapper
sxFunction_jac''''''''''''' :: SXFunctionClass a => a -> String -> String -> Bool -> IO SX
sxFunction_jac''''''''''''' x = casADi__SXFunction__jac''''''''''''' (castSXFunction x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXFunction__jac_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__SXFunction__jac_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC
  :: Ptr SXFunction' -> Ptr StdString' -> Ptr StdString' -> IO (Ptr SX')
casADi__SXFunction__jac''''''''''''''
  :: SXFunction -> String -> String -> IO SX
casADi__SXFunction__jac'''''''''''''' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__SXFunction__jac_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
sxFunction_jac'''''''''''''' :: SXFunctionClass a => a -> String -> String -> IO SX
sxFunction_jac'''''''''''''' x = casADi__SXFunction__jac'''''''''''''' (castSXFunction x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXFunction__grad" c_CasADi__SXFunction__grad
  :: Ptr SXFunction' -> CInt -> CInt -> IO (Ptr SX')
casADi__SXFunction__grad
  :: SXFunction -> Int -> Int -> IO SX
casADi__SXFunction__grad x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__SXFunction__grad x0' x1' x2' >>= wrapReturn

-- classy wrapper
{-|
>Gradient via source code transformation.
-}
sxFunction_grad :: SXFunctionClass a => a -> Int -> Int -> IO SX
sxFunction_grad x = casADi__SXFunction__grad (castSXFunction x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXFunction__grad_TIC" c_CasADi__SXFunction__grad_TIC
  :: Ptr SXFunction' -> CInt -> IO (Ptr SX')
casADi__SXFunction__grad'
  :: SXFunction -> Int -> IO SX
casADi__SXFunction__grad' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__SXFunction__grad_TIC x0' x1' >>= wrapReturn

-- classy wrapper
sxFunction_grad' :: SXFunctionClass a => a -> Int -> IO SX
sxFunction_grad' x = casADi__SXFunction__grad' (castSXFunction x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXFunction__grad_TIC_TIC" c_CasADi__SXFunction__grad_TIC_TIC
  :: Ptr SXFunction' -> IO (Ptr SX')
casADi__SXFunction__grad''
  :: SXFunction -> IO SX
casADi__SXFunction__grad'' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SXFunction__grad_TIC_TIC x0' >>= wrapReturn

-- classy wrapper
sxFunction_grad'' :: SXFunctionClass a => a -> IO SX
sxFunction_grad'' x = casADi__SXFunction__grad'' (castSXFunction x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXFunction__grad_TIC_TIC_TIC" c_CasADi__SXFunction__grad_TIC_TIC_TIC
  :: Ptr SXFunction' -> Ptr StdString' -> CInt -> IO (Ptr SX')
casADi__SXFunction__grad'''
  :: SXFunction -> String -> Int -> IO SX
casADi__SXFunction__grad''' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__SXFunction__grad_TIC_TIC_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
sxFunction_grad''' :: SXFunctionClass a => a -> String -> Int -> IO SX
sxFunction_grad''' x = casADi__SXFunction__grad''' (castSXFunction x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXFunction__grad_TIC_TIC_TIC_TIC" c_CasADi__SXFunction__grad_TIC_TIC_TIC_TIC
  :: Ptr SXFunction' -> Ptr StdString' -> IO (Ptr SX')
casADi__SXFunction__grad''''
  :: SXFunction -> String -> IO SX
casADi__SXFunction__grad'''' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__SXFunction__grad_TIC_TIC_TIC_TIC x0' x1' >>= wrapReturn

-- classy wrapper
sxFunction_grad'''' :: SXFunctionClass a => a -> String -> IO SX
sxFunction_grad'''' x = casADi__SXFunction__grad'''' (castSXFunction x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXFunction__grad_TIC_TIC_TIC_TIC_TIC" c_CasADi__SXFunction__grad_TIC_TIC_TIC_TIC_TIC
  :: Ptr SXFunction' -> CInt -> Ptr StdString' -> IO (Ptr SX')
casADi__SXFunction__grad'''''
  :: SXFunction -> Int -> String -> IO SX
casADi__SXFunction__grad''''' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__SXFunction__grad_TIC_TIC_TIC_TIC_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
sxFunction_grad''''' :: SXFunctionClass a => a -> Int -> String -> IO SX
sxFunction_grad''''' x = casADi__SXFunction__grad''''' (castSXFunction x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXFunction__grad_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__SXFunction__grad_TIC_TIC_TIC_TIC_TIC_TIC
  :: Ptr SXFunction' -> Ptr StdString' -> Ptr StdString' -> IO (Ptr SX')
casADi__SXFunction__grad''''''
  :: SXFunction -> String -> String -> IO SX
casADi__SXFunction__grad'''''' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__SXFunction__grad_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
sxFunction_grad'''''' :: SXFunctionClass a => a -> String -> String -> IO SX
sxFunction_grad'''''' x = casADi__SXFunction__grad'''''' (castSXFunction x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXFunction__tang" c_CasADi__SXFunction__tang
  :: Ptr SXFunction' -> CInt -> CInt -> IO (Ptr SX')
casADi__SXFunction__tang
  :: SXFunction -> Int -> Int -> IO SX
casADi__SXFunction__tang x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__SXFunction__tang x0' x1' x2' >>= wrapReturn

-- classy wrapper
{-|
>Tangent via source code transformation.
-}
sxFunction_tang :: SXFunctionClass a => a -> Int -> Int -> IO SX
sxFunction_tang x = casADi__SXFunction__tang (castSXFunction x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXFunction__tang_TIC" c_CasADi__SXFunction__tang_TIC
  :: Ptr SXFunction' -> CInt -> IO (Ptr SX')
casADi__SXFunction__tang'
  :: SXFunction -> Int -> IO SX
casADi__SXFunction__tang' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__SXFunction__tang_TIC x0' x1' >>= wrapReturn

-- classy wrapper
sxFunction_tang' :: SXFunctionClass a => a -> Int -> IO SX
sxFunction_tang' x = casADi__SXFunction__tang' (castSXFunction x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXFunction__tang_TIC_TIC" c_CasADi__SXFunction__tang_TIC_TIC
  :: Ptr SXFunction' -> IO (Ptr SX')
casADi__SXFunction__tang''
  :: SXFunction -> IO SX
casADi__SXFunction__tang'' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SXFunction__tang_TIC_TIC x0' >>= wrapReturn

-- classy wrapper
sxFunction_tang'' :: SXFunctionClass a => a -> IO SX
sxFunction_tang'' x = casADi__SXFunction__tang'' (castSXFunction x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXFunction__tang_TIC_TIC_TIC" c_CasADi__SXFunction__tang_TIC_TIC_TIC
  :: Ptr SXFunction' -> Ptr StdString' -> CInt -> IO (Ptr SX')
casADi__SXFunction__tang'''
  :: SXFunction -> String -> Int -> IO SX
casADi__SXFunction__tang''' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__SXFunction__tang_TIC_TIC_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
sxFunction_tang''' :: SXFunctionClass a => a -> String -> Int -> IO SX
sxFunction_tang''' x = casADi__SXFunction__tang''' (castSXFunction x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXFunction__tang_TIC_TIC_TIC_TIC" c_CasADi__SXFunction__tang_TIC_TIC_TIC_TIC
  :: Ptr SXFunction' -> Ptr StdString' -> IO (Ptr SX')
casADi__SXFunction__tang''''
  :: SXFunction -> String -> IO SX
casADi__SXFunction__tang'''' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__SXFunction__tang_TIC_TIC_TIC_TIC x0' x1' >>= wrapReturn

-- classy wrapper
sxFunction_tang'''' :: SXFunctionClass a => a -> String -> IO SX
sxFunction_tang'''' x = casADi__SXFunction__tang'''' (castSXFunction x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXFunction__tang_TIC_TIC_TIC_TIC_TIC" c_CasADi__SXFunction__tang_TIC_TIC_TIC_TIC_TIC
  :: Ptr SXFunction' -> CInt -> Ptr StdString' -> IO (Ptr SX')
casADi__SXFunction__tang'''''
  :: SXFunction -> Int -> String -> IO SX
casADi__SXFunction__tang''''' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__SXFunction__tang_TIC_TIC_TIC_TIC_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
sxFunction_tang''''' :: SXFunctionClass a => a -> Int -> String -> IO SX
sxFunction_tang''''' x = casADi__SXFunction__tang''''' (castSXFunction x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXFunction__tang_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__SXFunction__tang_TIC_TIC_TIC_TIC_TIC_TIC
  :: Ptr SXFunction' -> Ptr StdString' -> Ptr StdString' -> IO (Ptr SX')
casADi__SXFunction__tang''''''
  :: SXFunction -> String -> String -> IO SX
casADi__SXFunction__tang'''''' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__SXFunction__tang_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
sxFunction_tang'''''' :: SXFunctionClass a => a -> String -> String -> IO SX
sxFunction_tang'''''' x = casADi__SXFunction__tang'''''' (castSXFunction x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXFunction__hess" c_CasADi__SXFunction__hess
  :: Ptr SXFunction' -> CInt -> CInt -> IO (Ptr SX')
casADi__SXFunction__hess
  :: SXFunction -> Int -> Int -> IO SX
casADi__SXFunction__hess x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__SXFunction__hess x0' x1' x2' >>= wrapReturn

-- classy wrapper
{-|
>Hessian (forward over adjoint) via source code transformation.
-}
sxFunction_hess :: SXFunctionClass a => a -> Int -> Int -> IO SX
sxFunction_hess x = casADi__SXFunction__hess (castSXFunction x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXFunction__hess_TIC" c_CasADi__SXFunction__hess_TIC
  :: Ptr SXFunction' -> CInt -> IO (Ptr SX')
casADi__SXFunction__hess'
  :: SXFunction -> Int -> IO SX
casADi__SXFunction__hess' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__SXFunction__hess_TIC x0' x1' >>= wrapReturn

-- classy wrapper
sxFunction_hess' :: SXFunctionClass a => a -> Int -> IO SX
sxFunction_hess' x = casADi__SXFunction__hess' (castSXFunction x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXFunction__hess_TIC_TIC" c_CasADi__SXFunction__hess_TIC_TIC
  :: Ptr SXFunction' -> IO (Ptr SX')
casADi__SXFunction__hess''
  :: SXFunction -> IO SX
casADi__SXFunction__hess'' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SXFunction__hess_TIC_TIC x0' >>= wrapReturn

-- classy wrapper
sxFunction_hess'' :: SXFunctionClass a => a -> IO SX
sxFunction_hess'' x = casADi__SXFunction__hess'' (castSXFunction x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXFunction__hess_TIC_TIC_TIC" c_CasADi__SXFunction__hess_TIC_TIC_TIC
  :: Ptr SXFunction' -> Ptr StdString' -> CInt -> IO (Ptr SX')
casADi__SXFunction__hess'''
  :: SXFunction -> String -> Int -> IO SX
casADi__SXFunction__hess''' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__SXFunction__hess_TIC_TIC_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
sxFunction_hess''' :: SXFunctionClass a => a -> String -> Int -> IO SX
sxFunction_hess''' x = casADi__SXFunction__hess''' (castSXFunction x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXFunction__hess_TIC_TIC_TIC_TIC" c_CasADi__SXFunction__hess_TIC_TIC_TIC_TIC
  :: Ptr SXFunction' -> Ptr StdString' -> IO (Ptr SX')
casADi__SXFunction__hess''''
  :: SXFunction -> String -> IO SX
casADi__SXFunction__hess'''' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__SXFunction__hess_TIC_TIC_TIC_TIC x0' x1' >>= wrapReturn

-- classy wrapper
sxFunction_hess'''' :: SXFunctionClass a => a -> String -> IO SX
sxFunction_hess'''' x = casADi__SXFunction__hess'''' (castSXFunction x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXFunction__hess_TIC_TIC_TIC_TIC_TIC" c_CasADi__SXFunction__hess_TIC_TIC_TIC_TIC_TIC
  :: Ptr SXFunction' -> CInt -> Ptr StdString' -> IO (Ptr SX')
casADi__SXFunction__hess'''''
  :: SXFunction -> Int -> String -> IO SX
casADi__SXFunction__hess''''' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__SXFunction__hess_TIC_TIC_TIC_TIC_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
sxFunction_hess''''' :: SXFunctionClass a => a -> Int -> String -> IO SX
sxFunction_hess''''' x = casADi__SXFunction__hess''''' (castSXFunction x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXFunction__hess_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__SXFunction__hess_TIC_TIC_TIC_TIC_TIC_TIC
  :: Ptr SXFunction' -> Ptr StdString' -> Ptr StdString' -> IO (Ptr SX')
casADi__SXFunction__hess''''''
  :: SXFunction -> String -> String -> IO SX
casADi__SXFunction__hess'''''' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__SXFunction__hess_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
sxFunction_hess'''''' :: SXFunctionClass a => a -> String -> String -> IO SX
sxFunction_hess'''''' x = casADi__SXFunction__hess'''''' (castSXFunction x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXFunction__checkNode" c_CasADi__SXFunction__checkNode
  :: Ptr SXFunction' -> IO CInt
casADi__SXFunction__checkNode
  :: SXFunction -> IO Bool
casADi__SXFunction__checkNode x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SXFunction__checkNode x0' >>= wrapReturn

-- classy wrapper
{-|
>Check if the node is pointing to the right type of object.
-}
sxFunction_checkNode :: SXFunctionClass a => a -> IO Bool
sxFunction_checkNode x = casADi__SXFunction__checkNode (castSXFunction x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXFunction__getAlgorithmSize" c_CasADi__SXFunction__getAlgorithmSize
  :: Ptr SXFunction' -> IO CInt
casADi__SXFunction__getAlgorithmSize
  :: SXFunction -> IO Int
casADi__SXFunction__getAlgorithmSize x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SXFunction__getAlgorithmSize x0' >>= wrapReturn

-- classy wrapper
{-|
>Get the number of atomic operations.
-}
sxFunction_getAlgorithmSize :: SXFunctionClass a => a -> IO Int
sxFunction_getAlgorithmSize x = casADi__SXFunction__getAlgorithmSize (castSXFunction x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXFunction__getWorkSize" c_CasADi__SXFunction__getWorkSize
  :: Ptr SXFunction' -> IO CInt
casADi__SXFunction__getWorkSize
  :: SXFunction -> IO Int
casADi__SXFunction__getWorkSize x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SXFunction__getWorkSize x0' >>= wrapReturn

-- classy wrapper
{-|
>Get the length of the work vector.
-}
sxFunction_getWorkSize :: SXFunctionClass a => a -> IO Int
sxFunction_getWorkSize x = casADi__SXFunction__getWorkSize (castSXFunction x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXFunction__getAtomicOperation" c_CasADi__SXFunction__getAtomicOperation
  :: Ptr SXFunction' -> CInt -> IO CInt
casADi__SXFunction__getAtomicOperation
  :: SXFunction -> Int -> IO Int
casADi__SXFunction__getAtomicOperation x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__SXFunction__getAtomicOperation x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>Get an atomic operation operator index.
-}
sxFunction_getAtomicOperation :: SXFunctionClass a => a -> Int -> IO Int
sxFunction_getAtomicOperation x = casADi__SXFunction__getAtomicOperation (castSXFunction x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXFunction__getAtomicInputReal" c_CasADi__SXFunction__getAtomicInputReal
  :: Ptr SXFunction' -> CInt -> IO CDouble
casADi__SXFunction__getAtomicInputReal
  :: SXFunction -> Int -> IO Double
casADi__SXFunction__getAtomicInputReal x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__SXFunction__getAtomicInputReal x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>Get the floating point output argument of an atomic operation.
-}
sxFunction_getAtomicInputReal :: SXFunctionClass a => a -> Int -> IO Double
sxFunction_getAtomicInputReal x = casADi__SXFunction__getAtomicInputReal (castSXFunction x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXFunction__getAtomicOutput" c_CasADi__SXFunction__getAtomicOutput
  :: Ptr SXFunction' -> CInt -> IO CInt
casADi__SXFunction__getAtomicOutput
  :: SXFunction -> Int -> IO Int
casADi__SXFunction__getAtomicOutput x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__SXFunction__getAtomicOutput x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>Get the (integer) output argument of an atomic operation.
-}
sxFunction_getAtomicOutput :: SXFunctionClass a => a -> Int -> IO Int
sxFunction_getAtomicOutput x = casADi__SXFunction__getAtomicOutput (castSXFunction x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXFunction__countNodes" c_CasADi__SXFunction__countNodes
  :: Ptr SXFunction' -> IO CInt
casADi__SXFunction__countNodes
  :: SXFunction -> IO Int
casADi__SXFunction__countNodes x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SXFunction__countNodes x0' >>= wrapReturn

-- classy wrapper
{-|
>Number of nodes in the algorithm.
-}
sxFunction_countNodes :: SXFunctionClass a => a -> IO Int
sxFunction_countNodes x = casADi__SXFunction__countNodes (castSXFunction x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXFunction__clearSymbolic" c_CasADi__SXFunction__clearSymbolic
  :: Ptr SXFunction' -> IO ()
casADi__SXFunction__clearSymbolic
  :: SXFunction -> IO ()
casADi__SXFunction__clearSymbolic x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SXFunction__clearSymbolic x0' >>= wrapReturn

-- classy wrapper
{-|
>Clear the function from its symbolic representation, to free up memory, no
>symbolic evaluations are possible after this.
-}
sxFunction_clearSymbolic :: SXFunctionClass a => a -> IO ()
sxFunction_clearSymbolic x = casADi__SXFunction__clearSymbolic (castSXFunction x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXFunction__getFree" c_CasADi__SXFunction__getFree
  :: Ptr SXFunction' -> IO (Ptr (CppVec (Ptr SXElement')))
casADi__SXFunction__getFree
  :: SXFunction -> IO (Vector SXElement)
casADi__SXFunction__getFree x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SXFunction__getFree x0' >>= wrapReturn

-- classy wrapper
{-|
>Get all the free variables of the function.
-}
sxFunction_getFree :: SXFunctionClass a => a -> IO (Vector SXElement)
sxFunction_getFree x = casADi__SXFunction__getFree (castSXFunction x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXFunction__SXFunction" c_CasADi__SXFunction__SXFunction
  :: IO (Ptr SXFunction')
casADi__SXFunction__SXFunction
  :: IO SXFunction
casADi__SXFunction__SXFunction  =
  c_CasADi__SXFunction__SXFunction  >>= wrapReturn

-- classy wrapper
{-|
>>  CasADi::SXFunction::SXFunction()
>------------------------------------------------------------------------
>
>Default constructor.
>
>>  CasADi::SXFunction::SXFunction(const MXFunction &f)
>------------------------------------------------------------------------
>
>Expand an MXFunction.
>
>>  CasADi::SXFunction::SXFunction(const Function &f)
>------------------------------------------------------------------------
>
>Expand an Function.
>
>>  CasADi::SXFunction::SXFunction(const std::vector< SX > &arg, const std::vector< SX > &res)
>
>>  CasADi::SXFunction::SXFunction(const std::vector< SX > &arg, const IOSchemeVector< SX > &res)
>
>>  CasADi::SXFunction::SXFunction(const IOSchemeVector< SX > &arg, const std::vector< SX > &res)
>
>>  CasADi::SXFunction::SXFunction(const IOSchemeVector< SX > &arg, const IOSchemeVector< SX > &res)
>------------------------------------------------------------------------
>
>Multiple (matrix valued) input, multiple (matrix valued) output.
>
>>  CasADi::SXFunction::SXFunction(const std::vector< std::vector< SXElement > > &arg, const std::vector< std::vector< SXElement > > &res)
>------------------------------------------------------------------------
>[INTERNAL] 
>Multiple (vector valued) input, multiple (vector valued) output.
>
>>  CasADi::SXFunction::SXFunction(const SX &arg, const SX &res)
>------------------------------------------------------------------------
>[INTERNAL] 
>Single (scalar/matrix/vector valued) input, single
>(scalar/matrix/vector valued) output.
>
>>  CasADi::SXFunction::SXFunction(const std::vector< std::vector< SXElement > > &arg, const SX &res)
>------------------------------------------------------------------------
>[INTERNAL] 
>Multiple (vector valued) input, single (scalar/vector/matrix valued)
>output.
>
>>  CasADi::SXFunction::SXFunction(const std::vector< SX > &arg, const SX &res)
>------------------------------------------------------------------------
>[INTERNAL] 
>Multiple (matrix valued) input, single (scalar/vector/matrix valued)
>output.
>
>>  CasADi::SXFunction::SXFunction(const SX &arg, const std::vector< std::vector< SXElement > > &res)
>------------------------------------------------------------------------
>[INTERNAL] 
>Single (scalar/vector/matrix valued) input, multiple (vector valued)
>output.
>
>>  CasADi::SXFunction::SXFunction(const SX &arg, const std::vector< SX > &res)
>------------------------------------------------------------------------
>[INTERNAL] 
>Single (scalar/vector/matrix valued) input, multiple (matrix valued)
>output.
-}
sxFunction :: IO SXFunction
sxFunction = casADi__SXFunction__SXFunction


-- direct wrapper
foreign import ccall unsafe "CasADi__SXFunction__SXFunction_TIC" c_CasADi__SXFunction__SXFunction_TIC
  :: Ptr MXFunction' -> IO (Ptr SXFunction')
casADi__SXFunction__SXFunction'
  :: MXFunction -> IO SXFunction
casADi__SXFunction__SXFunction' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SXFunction__SXFunction_TIC x0' >>= wrapReturn

-- classy wrapper
sxFunction' :: MXFunction -> IO SXFunction
sxFunction' = casADi__SXFunction__SXFunction'


-- direct wrapper
foreign import ccall unsafe "CasADi__SXFunction__SXFunction_TIC_TIC" c_CasADi__SXFunction__SXFunction_TIC_TIC
  :: Ptr Function' -> IO (Ptr SXFunction')
casADi__SXFunction__SXFunction''
  :: Function -> IO SXFunction
casADi__SXFunction__SXFunction'' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SXFunction__SXFunction_TIC_TIC x0' >>= wrapReturn

-- classy wrapper
sxFunction'' :: Function -> IO SXFunction
sxFunction'' = casADi__SXFunction__SXFunction''


-- direct wrapper
foreign import ccall unsafe "CasADi__SXFunction__SXFunction_TIC_TIC_TIC" c_CasADi__SXFunction__SXFunction_TIC_TIC_TIC
  :: Ptr (CppVec (Ptr SX')) -> Ptr (CppVec (Ptr SX')) -> IO (Ptr SXFunction')
casADi__SXFunction__SXFunction'''
  :: Vector SX -> Vector SX -> IO SXFunction
casADi__SXFunction__SXFunction''' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__SXFunction__SXFunction_TIC_TIC_TIC x0' x1' >>= wrapReturn

-- classy wrapper
sxFunction''' :: Vector SX -> Vector SX -> IO SXFunction
sxFunction''' = casADi__SXFunction__SXFunction'''