{-# OPTIONS_GHC -Wall #-} {-# OPTIONS_GHC -fno-warn-unused-imports #-} {-# OPTIONS_GHC -fno-warn-orphans #-} {-# Language ForeignFunctionInterface #-} {-# Language FlexibleInstances #-} {-# Language MultiParamTypeClasses #-} module Casadi.Core.Classes.Function ( Function, FunctionClass(..), function, function_addMonitor, function_callDerivative__0, function_callDerivative__1, function_callDerivative__2, function_callDerivative__3, function_callDerivative__4, function_callDerivative__5, function_callDerivative__6, function_callDerivative__7, function_callDerivative__8, function_callForward__0, function_callForward__1, function_callForward__2, function_callForward__3, function_callForward__4, function_callForward__5, function_callForward__6, function_callForward__7, function_callForward__8, function_callReverse__0, function_callReverse__1, function_callReverse__2, function_callReverse__3, function_callReverse__4, function_callReverse__5, function_callReverse__6, function_callReverse__7, function_callReverse__8, function_call__0, function_call__1, function_call__2, function_call__3, function_call__4, function_call__5, function_call__6, function_call__7, function_call__8, function_checkInputs, function_defaultInput, function_derForward, function_derReverse, function_derivative, function_evaluate, function_fullJacobian, function_generate__0, function_generate__1, function_generate__2, function_generate__3, function_getSanitizedName, function_getStat, function_getStats, function_gradient__0, function_gradient__1, function_gradient__2, function_gradient__3, function_gradient__4, function_gradient__5, function_gradient__6, function_hessian__0, function_hessian__1, function_hessian__2, function_hessian__3, function_hessian__4, function_hessian__5, function_hessian__6, function_inputDescription, function_inputIndex, function_inputName, function_inputScheme, function_inputSparsity__0, function_inputSparsity__1, function_inputSparsity__2, function_jacSparsity__0, function_jacSparsity__1, function_jacSparsity__10, function_jacSparsity__11, function_jacSparsity__12, function_jacSparsity__13, function_jacSparsity__14, function_jacSparsity__2, function_jacSparsity__3, function_jacSparsity__4, function_jacSparsity__5, function_jacSparsity__6, function_jacSparsity__7, function_jacSparsity__8, function_jacSparsity__9, function_jacobian__0, function_jacobian__1, function_jacobian__10, function_jacobian__11, function_jacobian__12, function_jacobian__13, function_jacobian__14, function_jacobian__2, function_jacobian__3, function_jacobian__4, function_jacobian__5, function_jacobian__6, function_jacobian__7, function_jacobian__8, function_jacobian__9, function_map__0, function_map__1, function_map__2, function_map__3, function_map__4, function_map__5, function_mapaccum__0, function_mapaccum__1, function_mapsum__0, function_mapsum__1, function_nIn, function_nOut, function_nnzIn, function_nnzOut, function_numelIn, function_numelOut, function_operator_call__0, function_operator_call__1, function_operator_call__10, function_operator_call__11, function_operator_call__12, function_operator_call__13, function_operator_call__14, function_operator_call__15, function_operator_call__16, function_operator_call__17, function_operator_call__2, function_operator_call__3, function_operator_call__4, function_operator_call__5, function_operator_call__6, function_operator_call__7, function_operator_call__8, function_operator_call__9, function_outputDescription, function_outputIndex, function_outputName, function_outputScheme, function_outputSparsity__0, function_outputSparsity__1, function_outputSparsity__2, function_printDimensions, function_removeMonitor, function_sanitizeName, function_setDerForward, function_setDerReverse, function_setFullJacobian, function_setJacSparsity__0, function_setJacSparsity__1, function_setJacSparsity__2, function_setJacSparsity__3, function_setJacSparsity__4, function_setJacSparsity__5, function_setJacSparsity__6, function_setJacSparsity__7, function_setJacobian__0, function_setJacobian__1, function_setJacobian__2, function_setJacobian__3, function_spCanEvaluate, function_spEvaluate, function_spInit, function_symbolicInputSX, function_symbolicInput__0, function_symbolicInput__1, function_symbolicOutput, function_sz_arg, function_sz_iw, function_sz_res, function_sz_w, function_tangent__0, function_tangent__1, function_tangent__2, function_tangent__3, function_tangent__4, function_tangent__5, function_tangent__6, ) where import Prelude hiding ( Functor ) import Data.Vector ( Vector ) import qualified Data.Map as M import Foreign.C.Types import Foreign.Marshal ( new, free ) import Foreign.Storable ( peek ) import Foreign.Ptr ( Ptr, nullPtr ) import Foreign.ForeignPtr ( newForeignPtr ) import System.IO.Unsafe ( unsafePerformIO ) -- for show instances import Casadi.Internal.FormatException ( formatException ) import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream' import Casadi.Internal.Marshal ( Marshal(..), withMarshal ) import Casadi.Internal.WrapReturn ( WrapReturn(..) ) import Casadi.Core.Data import Casadi.Core.Enums -- direct wrapper foreign import ccall unsafe "casadi__Function__CONSTRUCTOR" c_casadi__Function__CONSTRUCTOR :: Ptr (Ptr StdString) -> IO (Ptr Function') casadi__Function__CONSTRUCTOR :: IO Function casadi__Function__CONSTRUCTOR = do errStrPtrP <- new nullPtr ret <- c_casadi__Function__CONSTRUCTOR errStrPtrP errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function :: IO Function function = casadi__Function__CONSTRUCTOR -- direct wrapper foreign import ccall unsafe "casadi__Function__addMonitor" c_casadi__Function__addMonitor :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO () casadi__Function__addMonitor :: Function -> String -> IO () casadi__Function__addMonitor x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__addMonitor errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_addMonitor :: FunctionClass a => a -> String -> IO () function_addMonitor x = casadi__Function__addMonitor (castFunction x) -- direct wrapper foreign import ccall safe "casadi__Function__call__0" c_casadi__Function__call__0 :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> IO () casadi__Function__call__0 :: Function -> Vector MX -> Vector MX -> IO () casadi__Function__call__0 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__call__0 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_call__0 :: FunctionClass a => a -> Vector MX -> Vector MX -> IO () function_call__0 x = casadi__Function__call__0 (castFunction x) -- direct wrapper foreign import ccall safe "casadi__Function__call__1" c_casadi__Function__call__1 :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> CInt -> IO () casadi__Function__call__1 :: Function -> Vector MX -> Vector MX -> Bool -> IO () casadi__Function__call__1 x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__call__1 errStrPtrP x0' x1' x2' x3' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_call__1 :: FunctionClass a => a -> Vector MX -> Vector MX -> Bool -> IO () function_call__1 x = casadi__Function__call__1 (castFunction x) -- direct wrapper foreign import ccall safe "casadi__Function__call__2" c_casadi__Function__call__2 :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> CInt -> CInt -> IO () casadi__Function__call__2 :: Function -> Vector MX -> Vector MX -> Bool -> Bool -> IO () casadi__Function__call__2 x0 x1 x2 x3 x4 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> withMarshal x4 $ \x4' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__call__2 errStrPtrP x0' x1' x2' x3' x4' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_call__2 :: FunctionClass a => a -> Vector MX -> Vector MX -> Bool -> Bool -> IO () function_call__2 x = casadi__Function__call__2 (castFunction x) -- direct wrapper foreign import ccall safe "casadi__Function__call__3" c_casadi__Function__call__3 :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> IO () casadi__Function__call__3 :: Function -> Vector SX -> Vector SX -> IO () casadi__Function__call__3 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__call__3 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_call__3 :: FunctionClass a => a -> Vector SX -> Vector SX -> IO () function_call__3 x = casadi__Function__call__3 (castFunction x) -- direct wrapper foreign import ccall safe "casadi__Function__call__4" c_casadi__Function__call__4 :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> CInt -> IO () casadi__Function__call__4 :: Function -> Vector SX -> Vector SX -> Bool -> IO () casadi__Function__call__4 x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__call__4 errStrPtrP x0' x1' x2' x3' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_call__4 :: FunctionClass a => a -> Vector SX -> Vector SX -> Bool -> IO () function_call__4 x = casadi__Function__call__4 (castFunction x) -- direct wrapper foreign import ccall safe "casadi__Function__call__5" c_casadi__Function__call__5 :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> CInt -> CInt -> IO () casadi__Function__call__5 :: Function -> Vector SX -> Vector SX -> Bool -> Bool -> IO () casadi__Function__call__5 x0 x1 x2 x3 x4 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> withMarshal x4 $ \x4' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__call__5 errStrPtrP x0' x1' x2' x3' x4' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_call__5 :: FunctionClass a => a -> Vector SX -> Vector SX -> Bool -> Bool -> IO () function_call__5 x = casadi__Function__call__5 (castFunction x) -- direct wrapper foreign import ccall safe "casadi__Function__call__6" c_casadi__Function__call__6 :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr DMatrix')) -> IO () casadi__Function__call__6 :: Function -> Vector DMatrix -> Vector DMatrix -> IO () casadi__Function__call__6 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__call__6 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_call__6 :: FunctionClass a => a -> Vector DMatrix -> Vector DMatrix -> IO () function_call__6 x = casadi__Function__call__6 (castFunction x) -- direct wrapper foreign import ccall safe "casadi__Function__call__7" c_casadi__Function__call__7 :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr DMatrix')) -> CInt -> IO () casadi__Function__call__7 :: Function -> Vector DMatrix -> Vector DMatrix -> Bool -> IO () casadi__Function__call__7 x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__call__7 errStrPtrP x0' x1' x2' x3' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_call__7 :: FunctionClass a => a -> Vector DMatrix -> Vector DMatrix -> Bool -> IO () function_call__7 x = casadi__Function__call__7 (castFunction x) -- direct wrapper foreign import ccall safe "casadi__Function__call__8" c_casadi__Function__call__8 :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr DMatrix')) -> CInt -> CInt -> IO () casadi__Function__call__8 :: Function -> Vector DMatrix -> Vector DMatrix -> Bool -> Bool -> IO () casadi__Function__call__8 x0 x1 x2 x3 x4 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> withMarshal x4 $ \x4' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__call__8 errStrPtrP x0' x1' x2' x3' x4' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_call__8 :: FunctionClass a => a -> Vector DMatrix -> Vector DMatrix -> Bool -> Bool -> IO () function_call__8 x = casadi__Function__call__8 (castFunction x) -- direct wrapper foreign import ccall safe "casadi__Function__callDerivative__0" c_casadi__Function__callDerivative__0 :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> IO () casadi__Function__callDerivative__0 :: Function -> Vector MX -> Vector MX -> Vector (Vector MX) -> Vector (Vector MX) -> Vector (Vector MX) -> Vector (Vector MX) -> IO () casadi__Function__callDerivative__0 x0 x1 x2 x3 x4 x5 x6 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> withMarshal x4 $ \x4' -> withMarshal x5 $ \x5' -> withMarshal x6 $ \x6' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__callDerivative__0 errStrPtrP x0' x1' x2' x3' x4' x5' x6' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_callDerivative__0 :: FunctionClass a => a -> Vector MX -> Vector MX -> Vector (Vector MX) -> Vector (Vector MX) -> Vector (Vector MX) -> Vector (Vector MX) -> IO () function_callDerivative__0 x = casadi__Function__callDerivative__0 (castFunction x) -- direct wrapper foreign import ccall safe "casadi__Function__callDerivative__1" c_casadi__Function__callDerivative__1 :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> CInt -> IO () casadi__Function__callDerivative__1 :: Function -> Vector MX -> Vector MX -> Vector (Vector MX) -> Vector (Vector MX) -> Vector (Vector MX) -> Vector (Vector MX) -> Bool -> IO () casadi__Function__callDerivative__1 x0 x1 x2 x3 x4 x5 x6 x7 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> withMarshal x4 $ \x4' -> withMarshal x5 $ \x5' -> withMarshal x6 $ \x6' -> withMarshal x7 $ \x7' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__callDerivative__1 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_callDerivative__1 :: FunctionClass a => a -> Vector MX -> Vector MX -> Vector (Vector MX) -> Vector (Vector MX) -> Vector (Vector MX) -> Vector (Vector MX) -> Bool -> IO () function_callDerivative__1 x = casadi__Function__callDerivative__1 (castFunction x) -- direct wrapper foreign import ccall safe "casadi__Function__callDerivative__2" c_casadi__Function__callDerivative__2 :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> CInt -> CInt -> IO () casadi__Function__callDerivative__2 :: Function -> Vector MX -> Vector MX -> Vector (Vector MX) -> Vector (Vector MX) -> Vector (Vector MX) -> Vector (Vector MX) -> Bool -> Bool -> IO () casadi__Function__callDerivative__2 x0 x1 x2 x3 x4 x5 x6 x7 x8 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> withMarshal x4 $ \x4' -> withMarshal x5 $ \x5' -> withMarshal x6 $ \x6' -> withMarshal x7 $ \x7' -> withMarshal x8 $ \x8' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__callDerivative__2 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_callDerivative__2 :: FunctionClass a => a -> Vector MX -> Vector MX -> Vector (Vector MX) -> Vector (Vector MX) -> Vector (Vector MX) -> Vector (Vector MX) -> Bool -> Bool -> IO () function_callDerivative__2 x = casadi__Function__callDerivative__2 (castFunction x) -- direct wrapper foreign import ccall safe "casadi__Function__callDerivative__3" c_casadi__Function__callDerivative__3 :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> IO () casadi__Function__callDerivative__3 :: Function -> Vector SX -> Vector SX -> Vector (Vector SX) -> Vector (Vector SX) -> Vector (Vector SX) -> Vector (Vector SX) -> IO () casadi__Function__callDerivative__3 x0 x1 x2 x3 x4 x5 x6 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> withMarshal x4 $ \x4' -> withMarshal x5 $ \x5' -> withMarshal x6 $ \x6' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__callDerivative__3 errStrPtrP x0' x1' x2' x3' x4' x5' x6' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_callDerivative__3 :: FunctionClass a => a -> Vector SX -> Vector SX -> Vector (Vector SX) -> Vector (Vector SX) -> Vector (Vector SX) -> Vector (Vector SX) -> IO () function_callDerivative__3 x = casadi__Function__callDerivative__3 (castFunction x) -- direct wrapper foreign import ccall safe "casadi__Function__callDerivative__4" c_casadi__Function__callDerivative__4 :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> CInt -> IO () casadi__Function__callDerivative__4 :: Function -> Vector SX -> Vector SX -> Vector (Vector SX) -> Vector (Vector SX) -> Vector (Vector SX) -> Vector (Vector SX) -> Bool -> IO () casadi__Function__callDerivative__4 x0 x1 x2 x3 x4 x5 x6 x7 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> withMarshal x4 $ \x4' -> withMarshal x5 $ \x5' -> withMarshal x6 $ \x6' -> withMarshal x7 $ \x7' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__callDerivative__4 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_callDerivative__4 :: FunctionClass a => a -> Vector SX -> Vector SX -> Vector (Vector SX) -> Vector (Vector SX) -> Vector (Vector SX) -> Vector (Vector SX) -> Bool -> IO () function_callDerivative__4 x = casadi__Function__callDerivative__4 (castFunction x) -- direct wrapper foreign import ccall safe "casadi__Function__callDerivative__5" c_casadi__Function__callDerivative__5 :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> CInt -> CInt -> IO () casadi__Function__callDerivative__5 :: Function -> Vector SX -> Vector SX -> Vector (Vector SX) -> Vector (Vector SX) -> Vector (Vector SX) -> Vector (Vector SX) -> Bool -> Bool -> IO () casadi__Function__callDerivative__5 x0 x1 x2 x3 x4 x5 x6 x7 x8 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> withMarshal x4 $ \x4' -> withMarshal x5 $ \x5' -> withMarshal x6 $ \x6' -> withMarshal x7 $ \x7' -> withMarshal x8 $ \x8' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__callDerivative__5 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_callDerivative__5 :: FunctionClass a => a -> Vector SX -> Vector SX -> Vector (Vector SX) -> Vector (Vector SX) -> Vector (Vector SX) -> Vector (Vector SX) -> Bool -> Bool -> IO () function_callDerivative__5 x = casadi__Function__callDerivative__5 (castFunction x) -- direct wrapper foreign import ccall safe "casadi__Function__callDerivative__6" c_casadi__Function__callDerivative__6 :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> IO () casadi__Function__callDerivative__6 :: Function -> Vector DMatrix -> Vector DMatrix -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> IO () casadi__Function__callDerivative__6 x0 x1 x2 x3 x4 x5 x6 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> withMarshal x4 $ \x4' -> withMarshal x5 $ \x5' -> withMarshal x6 $ \x6' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__callDerivative__6 errStrPtrP x0' x1' x2' x3' x4' x5' x6' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_callDerivative__6 :: FunctionClass a => a -> Vector DMatrix -> Vector DMatrix -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> IO () function_callDerivative__6 x = casadi__Function__callDerivative__6 (castFunction x) -- direct wrapper foreign import ccall safe "casadi__Function__callDerivative__7" c_casadi__Function__callDerivative__7 :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> CInt -> IO () casadi__Function__callDerivative__7 :: Function -> Vector DMatrix -> Vector DMatrix -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Bool -> IO () casadi__Function__callDerivative__7 x0 x1 x2 x3 x4 x5 x6 x7 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> withMarshal x4 $ \x4' -> withMarshal x5 $ \x5' -> withMarshal x6 $ \x6' -> withMarshal x7 $ \x7' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__callDerivative__7 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_callDerivative__7 :: FunctionClass a => a -> Vector DMatrix -> Vector DMatrix -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Bool -> IO () function_callDerivative__7 x = casadi__Function__callDerivative__7 (castFunction x) -- direct wrapper foreign import ccall safe "casadi__Function__callDerivative__8" c_casadi__Function__callDerivative__8 :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> CInt -> CInt -> IO () casadi__Function__callDerivative__8 :: Function -> Vector DMatrix -> Vector DMatrix -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Bool -> Bool -> IO () casadi__Function__callDerivative__8 x0 x1 x2 x3 x4 x5 x6 x7 x8 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> withMarshal x4 $ \x4' -> withMarshal x5 $ \x5' -> withMarshal x6 $ \x6' -> withMarshal x7 $ \x7' -> withMarshal x8 $ \x8' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__callDerivative__8 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_callDerivative__8 :: FunctionClass a => a -> Vector DMatrix -> Vector DMatrix -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Bool -> Bool -> IO () function_callDerivative__8 x = casadi__Function__callDerivative__8 (castFunction x) -- direct wrapper foreign import ccall safe "casadi__Function__callForward__0" c_casadi__Function__callForward__0 :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> IO () casadi__Function__callForward__0 :: Function -> Vector DMatrix -> Vector DMatrix -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> IO () casadi__Function__callForward__0 x0 x1 x2 x3 x4 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> withMarshal x4 $ \x4' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__callForward__0 errStrPtrP x0' x1' x2' x3' x4' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_callForward__0 :: FunctionClass a => a -> Vector DMatrix -> Vector DMatrix -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> IO () function_callForward__0 x = casadi__Function__callForward__0 (castFunction x) -- direct wrapper foreign import ccall safe "casadi__Function__callForward__1" c_casadi__Function__callForward__1 :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> CInt -> IO () casadi__Function__callForward__1 :: Function -> Vector DMatrix -> Vector DMatrix -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Bool -> IO () casadi__Function__callForward__1 x0 x1 x2 x3 x4 x5 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> withMarshal x4 $ \x4' -> withMarshal x5 $ \x5' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__callForward__1 errStrPtrP x0' x1' x2' x3' x4' x5' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_callForward__1 :: FunctionClass a => a -> Vector DMatrix -> Vector DMatrix -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Bool -> IO () function_callForward__1 x = casadi__Function__callForward__1 (castFunction x) -- direct wrapper foreign import ccall safe "casadi__Function__callForward__2" c_casadi__Function__callForward__2 :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> CInt -> CInt -> IO () casadi__Function__callForward__2 :: Function -> Vector DMatrix -> Vector DMatrix -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Bool -> Bool -> IO () casadi__Function__callForward__2 x0 x1 x2 x3 x4 x5 x6 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> withMarshal x4 $ \x4' -> withMarshal x5 $ \x5' -> withMarshal x6 $ \x6' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__callForward__2 errStrPtrP x0' x1' x2' x3' x4' x5' x6' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_callForward__2 :: FunctionClass a => a -> Vector DMatrix -> Vector DMatrix -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Bool -> Bool -> IO () function_callForward__2 x = casadi__Function__callForward__2 (castFunction x) -- direct wrapper foreign import ccall safe "casadi__Function__callForward__3" c_casadi__Function__callForward__3 :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> IO () casadi__Function__callForward__3 :: Function -> Vector SX -> Vector SX -> Vector (Vector SX) -> Vector (Vector SX) -> IO () casadi__Function__callForward__3 x0 x1 x2 x3 x4 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> withMarshal x4 $ \x4' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__callForward__3 errStrPtrP x0' x1' x2' x3' x4' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_callForward__3 :: FunctionClass a => a -> Vector SX -> Vector SX -> Vector (Vector SX) -> Vector (Vector SX) -> IO () function_callForward__3 x = casadi__Function__callForward__3 (castFunction x) -- direct wrapper foreign import ccall safe "casadi__Function__callForward__4" c_casadi__Function__callForward__4 :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> CInt -> IO () casadi__Function__callForward__4 :: Function -> Vector SX -> Vector SX -> Vector (Vector SX) -> Vector (Vector SX) -> Bool -> IO () casadi__Function__callForward__4 x0 x1 x2 x3 x4 x5 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> withMarshal x4 $ \x4' -> withMarshal x5 $ \x5' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__callForward__4 errStrPtrP x0' x1' x2' x3' x4' x5' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_callForward__4 :: FunctionClass a => a -> Vector SX -> Vector SX -> Vector (Vector SX) -> Vector (Vector SX) -> Bool -> IO () function_callForward__4 x = casadi__Function__callForward__4 (castFunction x) -- direct wrapper foreign import ccall safe "casadi__Function__callForward__5" c_casadi__Function__callForward__5 :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> CInt -> CInt -> IO () casadi__Function__callForward__5 :: Function -> Vector SX -> Vector SX -> Vector (Vector SX) -> Vector (Vector SX) -> Bool -> Bool -> IO () casadi__Function__callForward__5 x0 x1 x2 x3 x4 x5 x6 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> withMarshal x4 $ \x4' -> withMarshal x5 $ \x5' -> withMarshal x6 $ \x6' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__callForward__5 errStrPtrP x0' x1' x2' x3' x4' x5' x6' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_callForward__5 :: FunctionClass a => a -> Vector SX -> Vector SX -> Vector (Vector SX) -> Vector (Vector SX) -> Bool -> Bool -> IO () function_callForward__5 x = casadi__Function__callForward__5 (castFunction x) -- direct wrapper foreign import ccall safe "casadi__Function__callForward__6" c_casadi__Function__callForward__6 :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> IO () casadi__Function__callForward__6 :: Function -> Vector MX -> Vector MX -> Vector (Vector MX) -> Vector (Vector MX) -> IO () casadi__Function__callForward__6 x0 x1 x2 x3 x4 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> withMarshal x4 $ \x4' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__callForward__6 errStrPtrP x0' x1' x2' x3' x4' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_callForward__6 :: FunctionClass a => a -> Vector MX -> Vector MX -> Vector (Vector MX) -> Vector (Vector MX) -> IO () function_callForward__6 x = casadi__Function__callForward__6 (castFunction x) -- direct wrapper foreign import ccall safe "casadi__Function__callForward__7" c_casadi__Function__callForward__7 :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> CInt -> IO () casadi__Function__callForward__7 :: Function -> Vector MX -> Vector MX -> Vector (Vector MX) -> Vector (Vector MX) -> Bool -> IO () casadi__Function__callForward__7 x0 x1 x2 x3 x4 x5 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> withMarshal x4 $ \x4' -> withMarshal x5 $ \x5' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__callForward__7 errStrPtrP x0' x1' x2' x3' x4' x5' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_callForward__7 :: FunctionClass a => a -> Vector MX -> Vector MX -> Vector (Vector MX) -> Vector (Vector MX) -> Bool -> IO () function_callForward__7 x = casadi__Function__callForward__7 (castFunction x) -- direct wrapper foreign import ccall safe "casadi__Function__callForward__8" c_casadi__Function__callForward__8 :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> CInt -> CInt -> IO () casadi__Function__callForward__8 :: Function -> Vector MX -> Vector MX -> Vector (Vector MX) -> Vector (Vector MX) -> Bool -> Bool -> IO () casadi__Function__callForward__8 x0 x1 x2 x3 x4 x5 x6 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> withMarshal x4 $ \x4' -> withMarshal x5 $ \x5' -> withMarshal x6 $ \x6' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__callForward__8 errStrPtrP x0' x1' x2' x3' x4' x5' x6' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_callForward__8 :: FunctionClass a => a -> Vector MX -> Vector MX -> Vector (Vector MX) -> Vector (Vector MX) -> Bool -> Bool -> IO () function_callForward__8 x = casadi__Function__callForward__8 (castFunction x) -- direct wrapper foreign import ccall safe "casadi__Function__callReverse__0" c_casadi__Function__callReverse__0 :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> IO () casadi__Function__callReverse__0 :: Function -> Vector DMatrix -> Vector DMatrix -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> IO () casadi__Function__callReverse__0 x0 x1 x2 x3 x4 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> withMarshal x4 $ \x4' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__callReverse__0 errStrPtrP x0' x1' x2' x3' x4' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_callReverse__0 :: FunctionClass a => a -> Vector DMatrix -> Vector DMatrix -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> IO () function_callReverse__0 x = casadi__Function__callReverse__0 (castFunction x) -- direct wrapper foreign import ccall safe "casadi__Function__callReverse__1" c_casadi__Function__callReverse__1 :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> CInt -> IO () casadi__Function__callReverse__1 :: Function -> Vector DMatrix -> Vector DMatrix -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Bool -> IO () casadi__Function__callReverse__1 x0 x1 x2 x3 x4 x5 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> withMarshal x4 $ \x4' -> withMarshal x5 $ \x5' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__callReverse__1 errStrPtrP x0' x1' x2' x3' x4' x5' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_callReverse__1 :: FunctionClass a => a -> Vector DMatrix -> Vector DMatrix -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Bool -> IO () function_callReverse__1 x = casadi__Function__callReverse__1 (castFunction x) -- direct wrapper foreign import ccall safe "casadi__Function__callReverse__2" c_casadi__Function__callReverse__2 :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> CInt -> CInt -> IO () casadi__Function__callReverse__2 :: Function -> Vector DMatrix -> Vector DMatrix -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Bool -> Bool -> IO () casadi__Function__callReverse__2 x0 x1 x2 x3 x4 x5 x6 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> withMarshal x4 $ \x4' -> withMarshal x5 $ \x5' -> withMarshal x6 $ \x6' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__callReverse__2 errStrPtrP x0' x1' x2' x3' x4' x5' x6' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_callReverse__2 :: FunctionClass a => a -> Vector DMatrix -> Vector DMatrix -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Bool -> Bool -> IO () function_callReverse__2 x = casadi__Function__callReverse__2 (castFunction x) -- direct wrapper foreign import ccall safe "casadi__Function__callReverse__3" c_casadi__Function__callReverse__3 :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> IO () casadi__Function__callReverse__3 :: Function -> Vector SX -> Vector SX -> Vector (Vector SX) -> Vector (Vector SX) -> IO () casadi__Function__callReverse__3 x0 x1 x2 x3 x4 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> withMarshal x4 $ \x4' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__callReverse__3 errStrPtrP x0' x1' x2' x3' x4' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_callReverse__3 :: FunctionClass a => a -> Vector SX -> Vector SX -> Vector (Vector SX) -> Vector (Vector SX) -> IO () function_callReverse__3 x = casadi__Function__callReverse__3 (castFunction x) -- direct wrapper foreign import ccall safe "casadi__Function__callReverse__4" c_casadi__Function__callReverse__4 :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> CInt -> IO () casadi__Function__callReverse__4 :: Function -> Vector SX -> Vector SX -> Vector (Vector SX) -> Vector (Vector SX) -> Bool -> IO () casadi__Function__callReverse__4 x0 x1 x2 x3 x4 x5 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> withMarshal x4 $ \x4' -> withMarshal x5 $ \x5' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__callReverse__4 errStrPtrP x0' x1' x2' x3' x4' x5' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_callReverse__4 :: FunctionClass a => a -> Vector SX -> Vector SX -> Vector (Vector SX) -> Vector (Vector SX) -> Bool -> IO () function_callReverse__4 x = casadi__Function__callReverse__4 (castFunction x) -- direct wrapper foreign import ccall safe "casadi__Function__callReverse__5" c_casadi__Function__callReverse__5 :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> CInt -> CInt -> IO () casadi__Function__callReverse__5 :: Function -> Vector SX -> Vector SX -> Vector (Vector SX) -> Vector (Vector SX) -> Bool -> Bool -> IO () casadi__Function__callReverse__5 x0 x1 x2 x3 x4 x5 x6 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> withMarshal x4 $ \x4' -> withMarshal x5 $ \x5' -> withMarshal x6 $ \x6' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__callReverse__5 errStrPtrP x0' x1' x2' x3' x4' x5' x6' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_callReverse__5 :: FunctionClass a => a -> Vector SX -> Vector SX -> Vector (Vector SX) -> Vector (Vector SX) -> Bool -> Bool -> IO () function_callReverse__5 x = casadi__Function__callReverse__5 (castFunction x) -- direct wrapper foreign import ccall safe "casadi__Function__callReverse__6" c_casadi__Function__callReverse__6 :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> IO () casadi__Function__callReverse__6 :: Function -> Vector MX -> Vector MX -> Vector (Vector MX) -> Vector (Vector MX) -> IO () casadi__Function__callReverse__6 x0 x1 x2 x3 x4 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> withMarshal x4 $ \x4' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__callReverse__6 errStrPtrP x0' x1' x2' x3' x4' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_callReverse__6 :: FunctionClass a => a -> Vector MX -> Vector MX -> Vector (Vector MX) -> Vector (Vector MX) -> IO () function_callReverse__6 x = casadi__Function__callReverse__6 (castFunction x) -- direct wrapper foreign import ccall safe "casadi__Function__callReverse__7" c_casadi__Function__callReverse__7 :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> CInt -> IO () casadi__Function__callReverse__7 :: Function -> Vector MX -> Vector MX -> Vector (Vector MX) -> Vector (Vector MX) -> Bool -> IO () casadi__Function__callReverse__7 x0 x1 x2 x3 x4 x5 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> withMarshal x4 $ \x4' -> withMarshal x5 $ \x5' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__callReverse__7 errStrPtrP x0' x1' x2' x3' x4' x5' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_callReverse__7 :: FunctionClass a => a -> Vector MX -> Vector MX -> Vector (Vector MX) -> Vector (Vector MX) -> Bool -> IO () function_callReverse__7 x = casadi__Function__callReverse__7 (castFunction x) -- direct wrapper foreign import ccall safe "casadi__Function__callReverse__8" c_casadi__Function__callReverse__8 :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> CInt -> CInt -> IO () casadi__Function__callReverse__8 :: Function -> Vector MX -> Vector MX -> Vector (Vector MX) -> Vector (Vector MX) -> Bool -> Bool -> IO () casadi__Function__callReverse__8 x0 x1 x2 x3 x4 x5 x6 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> withMarshal x4 $ \x4' -> withMarshal x5 $ \x5' -> withMarshal x6 $ \x6' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__callReverse__8 errStrPtrP x0' x1' x2' x3' x4' x5' x6' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_callReverse__8 :: FunctionClass a => a -> Vector MX -> Vector MX -> Vector (Vector MX) -> Vector (Vector MX) -> Bool -> Bool -> IO () function_callReverse__8 x = casadi__Function__callReverse__8 (castFunction x) -- direct wrapper foreign import ccall unsafe "casadi__Function__checkInputs" c_casadi__Function__checkInputs :: Ptr (Ptr StdString) -> Ptr Function' -> IO () casadi__Function__checkInputs :: Function -> IO () casadi__Function__checkInputs x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__checkInputs errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_checkInputs :: FunctionClass a => a -> IO () function_checkInputs x = casadi__Function__checkInputs (castFunction x) -- direct wrapper foreign import ccall unsafe "casadi__Function__defaultInput" c_casadi__Function__defaultInput :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO CDouble casadi__Function__defaultInput :: Function -> Int -> IO Double casadi__Function__defaultInput x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__defaultInput errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_defaultInput :: FunctionClass a => a -> Int -> IO Double function_defaultInput x = casadi__Function__defaultInput (castFunction x) -- direct wrapper foreign import ccall unsafe "casadi__Function__derForward" c_casadi__Function__derForward :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO (Ptr Function') casadi__Function__derForward :: Function -> Int -> IO Function casadi__Function__derForward x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__derForward errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_derForward :: FunctionClass a => a -> Int -> IO Function function_derForward x = casadi__Function__derForward (castFunction x) -- direct wrapper foreign import ccall unsafe "casadi__Function__derReverse" c_casadi__Function__derReverse :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO (Ptr Function') casadi__Function__derReverse :: Function -> Int -> IO Function casadi__Function__derReverse x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__derReverse errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_derReverse :: FunctionClass a => a -> Int -> IO Function function_derReverse x = casadi__Function__derReverse (castFunction x) -- direct wrapper foreign import ccall safe "casadi__Function__derivative" c_casadi__Function__derivative :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> CInt -> IO (Ptr Function') casadi__Function__derivative :: Function -> Int -> Int -> IO Function casadi__Function__derivative x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__derivative errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_derivative :: FunctionClass a => a -> Int -> Int -> IO Function function_derivative x = casadi__Function__derivative (castFunction x) -- direct wrapper foreign import ccall safe "casadi__Function__evaluate" c_casadi__Function__evaluate :: Ptr (Ptr StdString) -> Ptr Function' -> IO () casadi__Function__evaluate :: Function -> IO () casadi__Function__evaluate x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__evaluate errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_evaluate :: FunctionClass a => a -> IO () function_evaluate x = casadi__Function__evaluate (castFunction x) -- direct wrapper foreign import ccall unsafe "casadi__Function__fullJacobian" c_casadi__Function__fullJacobian :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr Function') casadi__Function__fullJacobian :: Function -> IO Function casadi__Function__fullJacobian x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__fullJacobian errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_fullJacobian :: FunctionClass a => a -> IO Function function_fullJacobian x = casadi__Function__fullJacobian (castFunction x) -- direct wrapper foreign import ccall unsafe "casadi__Function__generate__0" c_casadi__Function__generate__0 :: Ptr (Ptr StdString) -> Ptr Function' -> IO () casadi__Function__generate__0 :: Function -> IO () casadi__Function__generate__0 x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__generate__0 errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_generate__0 :: FunctionClass a => a -> IO () function_generate__0 x = casadi__Function__generate__0 (castFunction x) -- direct wrapper foreign import ccall unsafe "casadi__Function__generate__1" c_casadi__Function__generate__1 :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdMap StdString (Ptr GenericType')) -> IO () casadi__Function__generate__1 :: Function -> M.Map String GenericType -> IO () casadi__Function__generate__1 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__generate__1 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_generate__1 :: FunctionClass a => a -> M.Map String GenericType -> IO () function_generate__1 x = casadi__Function__generate__1 (castFunction x) -- direct wrapper foreign import ccall unsafe "casadi__Function__generate__2" c_casadi__Function__generate__2 :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO () casadi__Function__generate__2 :: Function -> String -> IO () casadi__Function__generate__2 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__generate__2 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_generate__2 :: FunctionClass a => a -> String -> IO () function_generate__2 x = casadi__Function__generate__2 (castFunction x) -- direct wrapper foreign import ccall unsafe "casadi__Function__generate__3" c_casadi__Function__generate__3 :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> Ptr (StdMap StdString (Ptr GenericType')) -> IO () casadi__Function__generate__3 :: Function -> String -> M.Map String GenericType -> IO () casadi__Function__generate__3 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__generate__3 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_generate__3 :: FunctionClass a => a -> String -> M.Map String GenericType -> IO () function_generate__3 x = casadi__Function__generate__3 (castFunction x) -- direct wrapper foreign import ccall unsafe "casadi__Function__getSanitizedName" c_casadi__Function__getSanitizedName :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr StdString) casadi__Function__getSanitizedName :: Function -> IO String casadi__Function__getSanitizedName x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__getSanitizedName errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_getSanitizedName :: FunctionClass a => a -> IO String function_getSanitizedName x = casadi__Function__getSanitizedName (castFunction x) -- direct wrapper foreign import ccall unsafe "casadi__Function__getStat" c_casadi__Function__getStat :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO (Ptr GenericType') casadi__Function__getStat :: Function -> String -> IO GenericType casadi__Function__getStat x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__getStat errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_getStat :: FunctionClass a => a -> String -> IO GenericType function_getStat x = casadi__Function__getStat (castFunction x) -- direct wrapper foreign import ccall unsafe "casadi__Function__getStats" c_casadi__Function__getStats :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr (StdMap StdString (Ptr GenericType'))) casadi__Function__getStats :: Function -> IO (M.Map String GenericType) casadi__Function__getStats x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__getStats errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_getStats :: FunctionClass a => a -> IO (M.Map String GenericType) function_getStats x = casadi__Function__getStats (castFunction x) -- direct wrapper foreign import ccall safe "casadi__Function__gradient__0" c_casadi__Function__gradient__0 :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> Ptr StdString -> IO (Ptr Function') casadi__Function__gradient__0 :: Function -> String -> String -> IO Function casadi__Function__gradient__0 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__gradient__0 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_gradient__0 :: FunctionClass a => a -> String -> String -> IO Function function_gradient__0 x = casadi__Function__gradient__0 (castFunction x) -- direct wrapper foreign import ccall safe "casadi__Function__gradient__1" c_casadi__Function__gradient__1 :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> Ptr StdString -> IO (Ptr Function') casadi__Function__gradient__1 :: Function -> Int -> String -> IO Function casadi__Function__gradient__1 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__gradient__1 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_gradient__1 :: FunctionClass a => a -> Int -> String -> IO Function function_gradient__1 x = casadi__Function__gradient__1 (castFunction x) -- direct wrapper foreign import ccall safe "casadi__Function__gradient__2" c_casadi__Function__gradient__2 :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO (Ptr Function') casadi__Function__gradient__2 :: Function -> String -> IO Function casadi__Function__gradient__2 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__gradient__2 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_gradient__2 :: FunctionClass a => a -> String -> IO Function function_gradient__2 x = casadi__Function__gradient__2 (castFunction x) -- direct wrapper foreign import ccall safe "casadi__Function__gradient__3" c_casadi__Function__gradient__3 :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> CInt -> IO (Ptr Function') casadi__Function__gradient__3 :: Function -> String -> Int -> IO Function casadi__Function__gradient__3 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__gradient__3 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_gradient__3 :: FunctionClass a => a -> String -> Int -> IO Function function_gradient__3 x = casadi__Function__gradient__3 (castFunction x) -- direct wrapper foreign import ccall safe "casadi__Function__gradient__4" c_casadi__Function__gradient__4 :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr Function') casadi__Function__gradient__4 :: Function -> IO Function casadi__Function__gradient__4 x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__gradient__4 errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_gradient__4 :: FunctionClass a => a -> IO Function function_gradient__4 x = casadi__Function__gradient__4 (castFunction x) -- direct wrapper foreign import ccall safe "casadi__Function__gradient__5" c_casadi__Function__gradient__5 :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO (Ptr Function') casadi__Function__gradient__5 :: Function -> Int -> IO Function casadi__Function__gradient__5 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__gradient__5 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_gradient__5 :: FunctionClass a => a -> Int -> IO Function function_gradient__5 x = casadi__Function__gradient__5 (castFunction x) -- direct wrapper foreign import ccall safe "casadi__Function__gradient__6" c_casadi__Function__gradient__6 :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> CInt -> IO (Ptr Function') casadi__Function__gradient__6 :: Function -> Int -> Int -> IO Function casadi__Function__gradient__6 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__gradient__6 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_gradient__6 :: FunctionClass a => a -> Int -> Int -> IO Function function_gradient__6 x = casadi__Function__gradient__6 (castFunction x) -- direct wrapper foreign import ccall safe "casadi__Function__hessian__0" c_casadi__Function__hessian__0 :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> Ptr StdString -> IO (Ptr Function') casadi__Function__hessian__0 :: Function -> String -> String -> IO Function casadi__Function__hessian__0 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__hessian__0 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_hessian__0 :: FunctionClass a => a -> String -> String -> IO Function function_hessian__0 x = casadi__Function__hessian__0 (castFunction x) -- direct wrapper foreign import ccall safe "casadi__Function__hessian__1" c_casadi__Function__hessian__1 :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> Ptr StdString -> IO (Ptr Function') casadi__Function__hessian__1 :: Function -> Int -> String -> IO Function casadi__Function__hessian__1 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__hessian__1 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_hessian__1 :: FunctionClass a => a -> Int -> String -> IO Function function_hessian__1 x = casadi__Function__hessian__1 (castFunction x) -- direct wrapper foreign import ccall safe "casadi__Function__hessian__2" c_casadi__Function__hessian__2 :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO (Ptr Function') casadi__Function__hessian__2 :: Function -> String -> IO Function casadi__Function__hessian__2 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__hessian__2 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_hessian__2 :: FunctionClass a => a -> String -> IO Function function_hessian__2 x = casadi__Function__hessian__2 (castFunction x) -- direct wrapper foreign import ccall safe "casadi__Function__hessian__3" c_casadi__Function__hessian__3 :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> CInt -> IO (Ptr Function') casadi__Function__hessian__3 :: Function -> String -> Int -> IO Function casadi__Function__hessian__3 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__hessian__3 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_hessian__3 :: FunctionClass a => a -> String -> Int -> IO Function function_hessian__3 x = casadi__Function__hessian__3 (castFunction x) -- direct wrapper foreign import ccall safe "casadi__Function__hessian__4" c_casadi__Function__hessian__4 :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr Function') casadi__Function__hessian__4 :: Function -> IO Function casadi__Function__hessian__4 x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__hessian__4 errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_hessian__4 :: FunctionClass a => a -> IO Function function_hessian__4 x = casadi__Function__hessian__4 (castFunction x) -- direct wrapper foreign import ccall safe "casadi__Function__hessian__5" c_casadi__Function__hessian__5 :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO (Ptr Function') casadi__Function__hessian__5 :: Function -> Int -> IO Function casadi__Function__hessian__5 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__hessian__5 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_hessian__5 :: FunctionClass a => a -> Int -> IO Function function_hessian__5 x = casadi__Function__hessian__5 (castFunction x) -- direct wrapper foreign import ccall safe "casadi__Function__hessian__6" c_casadi__Function__hessian__6 :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> CInt -> IO (Ptr Function') casadi__Function__hessian__6 :: Function -> Int -> Int -> IO Function casadi__Function__hessian__6 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__hessian__6 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_hessian__6 :: FunctionClass a => a -> Int -> Int -> IO Function function_hessian__6 x = casadi__Function__hessian__6 (castFunction x) -- direct wrapper foreign import ccall unsafe "casadi__Function__inputDescription" c_casadi__Function__inputDescription :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO (Ptr StdString) casadi__Function__inputDescription :: Function -> Int -> IO String casadi__Function__inputDescription x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__inputDescription errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_inputDescription :: FunctionClass a => a -> Int -> IO String function_inputDescription x = casadi__Function__inputDescription (castFunction x) -- direct wrapper foreign import ccall unsafe "casadi__Function__inputIndex" c_casadi__Function__inputIndex :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO CInt casadi__Function__inputIndex :: Function -> String -> IO Int casadi__Function__inputIndex x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__inputIndex errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_inputIndex :: FunctionClass a => a -> String -> IO Int function_inputIndex x = casadi__Function__inputIndex (castFunction x) -- direct wrapper foreign import ccall unsafe "casadi__Function__inputName" c_casadi__Function__inputName :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO (Ptr StdString) casadi__Function__inputName :: Function -> Int -> IO String casadi__Function__inputName x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__inputName errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_inputName :: FunctionClass a => a -> Int -> IO String function_inputName x = casadi__Function__inputName (castFunction x) -- direct wrapper foreign import ccall unsafe "casadi__Function__inputScheme" c_casadi__Function__inputScheme :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr (StdVec (Ptr StdString))) casadi__Function__inputScheme :: Function -> IO (Vector String) casadi__Function__inputScheme x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__inputScheme errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_inputScheme :: FunctionClass a => a -> IO (Vector String) function_inputScheme x = casadi__Function__inputScheme (castFunction x) -- direct wrapper foreign import ccall unsafe "casadi__Function__inputSparsity__0" c_casadi__Function__inputSparsity__0 :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO (Ptr Sparsity') casadi__Function__inputSparsity__0 :: Function -> String -> IO Sparsity casadi__Function__inputSparsity__0 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__inputSparsity__0 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_inputSparsity__0 :: FunctionClass a => a -> String -> IO Sparsity function_inputSparsity__0 x = casadi__Function__inputSparsity__0 (castFunction x) -- direct wrapper foreign import ccall unsafe "casadi__Function__inputSparsity__1" c_casadi__Function__inputSparsity__1 :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr Sparsity') casadi__Function__inputSparsity__1 :: Function -> IO Sparsity casadi__Function__inputSparsity__1 x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__inputSparsity__1 errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_inputSparsity__1 :: FunctionClass a => a -> IO Sparsity function_inputSparsity__1 x = casadi__Function__inputSparsity__1 (castFunction x) -- direct wrapper foreign import ccall unsafe "casadi__Function__inputSparsity__2" c_casadi__Function__inputSparsity__2 :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO (Ptr Sparsity') casadi__Function__inputSparsity__2 :: Function -> Int -> IO Sparsity casadi__Function__inputSparsity__2 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__inputSparsity__2 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_inputSparsity__2 :: FunctionClass a => a -> Int -> IO Sparsity function_inputSparsity__2 x = casadi__Function__inputSparsity__2 (castFunction x) -- direct wrapper foreign import ccall unsafe "casadi__Function__jacSparsity__0" c_casadi__Function__jacSparsity__0 :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> Ptr StdString -> IO (Ptr Sparsity') casadi__Function__jacSparsity__0 :: Function -> String -> String -> IO Sparsity casadi__Function__jacSparsity__0 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__jacSparsity__0 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_jacSparsity__0 :: FunctionClass a => a -> String -> String -> IO Sparsity function_jacSparsity__0 x = casadi__Function__jacSparsity__0 (castFunction x) -- direct wrapper foreign import ccall unsafe "casadi__Function__jacSparsity__1" c_casadi__Function__jacSparsity__1 :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> Ptr StdString -> CInt -> IO (Ptr Sparsity') casadi__Function__jacSparsity__1 :: Function -> String -> String -> Bool -> IO Sparsity casadi__Function__jacSparsity__1 x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__jacSparsity__1 errStrPtrP x0' x1' x2' x3' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_jacSparsity__1 :: FunctionClass a => a -> String -> String -> Bool -> IO Sparsity function_jacSparsity__1 x = casadi__Function__jacSparsity__1 (castFunction x) -- direct wrapper foreign import ccall unsafe "casadi__Function__jacSparsity__2" c_casadi__Function__jacSparsity__2 :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> Ptr StdString -> CInt -> CInt -> IO (Ptr Sparsity') casadi__Function__jacSparsity__2 :: Function -> String -> String -> Bool -> Bool -> IO Sparsity casadi__Function__jacSparsity__2 x0 x1 x2 x3 x4 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> withMarshal x4 $ \x4' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__jacSparsity__2 errStrPtrP x0' x1' x2' x3' x4' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_jacSparsity__2 :: FunctionClass a => a -> String -> String -> Bool -> Bool -> IO Sparsity function_jacSparsity__2 x = casadi__Function__jacSparsity__2 (castFunction x) -- direct wrapper foreign import ccall unsafe "casadi__Function__jacSparsity__3" c_casadi__Function__jacSparsity__3 :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> Ptr StdString -> IO (Ptr Sparsity') casadi__Function__jacSparsity__3 :: Function -> Int -> String -> IO Sparsity casadi__Function__jacSparsity__3 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__jacSparsity__3 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_jacSparsity__3 :: FunctionClass a => a -> Int -> String -> IO Sparsity function_jacSparsity__3 x = casadi__Function__jacSparsity__3 (castFunction x) -- direct wrapper foreign import ccall unsafe "casadi__Function__jacSparsity__4" c_casadi__Function__jacSparsity__4 :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> Ptr StdString -> CInt -> IO (Ptr Sparsity') casadi__Function__jacSparsity__4 :: Function -> Int -> String -> Bool -> IO Sparsity casadi__Function__jacSparsity__4 x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__jacSparsity__4 errStrPtrP x0' x1' x2' x3' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_jacSparsity__4 :: FunctionClass a => a -> Int -> String -> Bool -> IO Sparsity function_jacSparsity__4 x = casadi__Function__jacSparsity__4 (castFunction x) -- direct wrapper foreign import ccall unsafe "casadi__Function__jacSparsity__5" c_casadi__Function__jacSparsity__5 :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> Ptr StdString -> CInt -> CInt -> IO (Ptr Sparsity') casadi__Function__jacSparsity__5 :: Function -> Int -> String -> Bool -> Bool -> IO Sparsity casadi__Function__jacSparsity__5 x0 x1 x2 x3 x4 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> withMarshal x4 $ \x4' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__jacSparsity__5 errStrPtrP x0' x1' x2' x3' x4' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_jacSparsity__5 :: FunctionClass a => a -> Int -> String -> Bool -> Bool -> IO Sparsity function_jacSparsity__5 x = casadi__Function__jacSparsity__5 (castFunction x) -- direct wrapper foreign import ccall unsafe "casadi__Function__jacSparsity__6" c_casadi__Function__jacSparsity__6 :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO (Ptr Sparsity') casadi__Function__jacSparsity__6 :: Function -> String -> IO Sparsity casadi__Function__jacSparsity__6 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__jacSparsity__6 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_jacSparsity__6 :: FunctionClass a => a -> String -> IO Sparsity function_jacSparsity__6 x = casadi__Function__jacSparsity__6 (castFunction x) -- direct wrapper foreign import ccall unsafe "casadi__Function__jacSparsity__7" c_casadi__Function__jacSparsity__7 :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> CInt -> IO (Ptr Sparsity') casadi__Function__jacSparsity__7 :: Function -> String -> Int -> IO Sparsity casadi__Function__jacSparsity__7 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__jacSparsity__7 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_jacSparsity__7 :: FunctionClass a => a -> String -> Int -> IO Sparsity function_jacSparsity__7 x = casadi__Function__jacSparsity__7 (castFunction x) -- direct wrapper foreign import ccall unsafe "casadi__Function__jacSparsity__8" c_casadi__Function__jacSparsity__8 :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> CInt -> CInt -> IO (Ptr Sparsity') casadi__Function__jacSparsity__8 :: Function -> String -> Int -> Bool -> IO Sparsity casadi__Function__jacSparsity__8 x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__jacSparsity__8 errStrPtrP x0' x1' x2' x3' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_jacSparsity__8 :: FunctionClass a => a -> String -> Int -> Bool -> IO Sparsity function_jacSparsity__8 x = casadi__Function__jacSparsity__8 (castFunction x) -- direct wrapper foreign import ccall unsafe "casadi__Function__jacSparsity__9" c_casadi__Function__jacSparsity__9 :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> CInt -> CInt -> CInt -> IO (Ptr Sparsity') casadi__Function__jacSparsity__9 :: Function -> String -> Int -> Bool -> Bool -> IO Sparsity casadi__Function__jacSparsity__9 x0 x1 x2 x3 x4 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> withMarshal x4 $ \x4' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__jacSparsity__9 errStrPtrP x0' x1' x2' x3' x4' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_jacSparsity__9 :: FunctionClass a => a -> String -> Int -> Bool -> Bool -> IO Sparsity function_jacSparsity__9 x = casadi__Function__jacSparsity__9 (castFunction x) -- direct wrapper foreign import ccall unsafe "casadi__Function__jacSparsity__10" c_casadi__Function__jacSparsity__10 :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr Sparsity') casadi__Function__jacSparsity__10 :: Function -> IO Sparsity casadi__Function__jacSparsity__10 x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__jacSparsity__10 errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_jacSparsity__10 :: FunctionClass a => a -> IO Sparsity function_jacSparsity__10 x = casadi__Function__jacSparsity__10 (castFunction x) -- direct wrapper foreign import ccall unsafe "casadi__Function__jacSparsity__11" c_casadi__Function__jacSparsity__11 :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO (Ptr Sparsity') casadi__Function__jacSparsity__11 :: Function -> Int -> IO Sparsity casadi__Function__jacSparsity__11 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__jacSparsity__11 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_jacSparsity__11 :: FunctionClass a => a -> Int -> IO Sparsity function_jacSparsity__11 x = casadi__Function__jacSparsity__11 (castFunction x) -- direct wrapper foreign import ccall unsafe "casadi__Function__jacSparsity__12" c_casadi__Function__jacSparsity__12 :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> CInt -> IO (Ptr Sparsity') casadi__Function__jacSparsity__12 :: Function -> Int -> Int -> IO Sparsity casadi__Function__jacSparsity__12 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__jacSparsity__12 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_jacSparsity__12 :: FunctionClass a => a -> Int -> Int -> IO Sparsity function_jacSparsity__12 x = casadi__Function__jacSparsity__12 (castFunction x) -- direct wrapper foreign import ccall unsafe "casadi__Function__jacSparsity__13" c_casadi__Function__jacSparsity__13 :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> CInt -> CInt -> IO (Ptr Sparsity') casadi__Function__jacSparsity__13 :: Function -> Int -> Int -> Bool -> IO Sparsity casadi__Function__jacSparsity__13 x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__jacSparsity__13 errStrPtrP x0' x1' x2' x3' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_jacSparsity__13 :: FunctionClass a => a -> Int -> Int -> Bool -> IO Sparsity function_jacSparsity__13 x = casadi__Function__jacSparsity__13 (castFunction x) -- direct wrapper foreign import ccall unsafe "casadi__Function__jacSparsity__14" c_casadi__Function__jacSparsity__14 :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> CInt -> CInt -> CInt -> IO (Ptr Sparsity') casadi__Function__jacSparsity__14 :: Function -> Int -> Int -> Bool -> Bool -> IO Sparsity casadi__Function__jacSparsity__14 x0 x1 x2 x3 x4 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> withMarshal x4 $ \x4' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__jacSparsity__14 errStrPtrP x0' x1' x2' x3' x4' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_jacSparsity__14 :: FunctionClass a => a -> Int -> Int -> Bool -> Bool -> IO Sparsity function_jacSparsity__14 x = casadi__Function__jacSparsity__14 (castFunction x) -- direct wrapper foreign import ccall safe "casadi__Function__jacobian__0" c_casadi__Function__jacobian__0 :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> Ptr StdString -> IO (Ptr Function') casadi__Function__jacobian__0 :: Function -> String -> String -> IO Function casadi__Function__jacobian__0 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__jacobian__0 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_jacobian__0 :: FunctionClass a => a -> String -> String -> IO Function function_jacobian__0 x = casadi__Function__jacobian__0 (castFunction x) -- direct wrapper foreign import ccall safe "casadi__Function__jacobian__1" c_casadi__Function__jacobian__1 :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> Ptr StdString -> CInt -> IO (Ptr Function') casadi__Function__jacobian__1 :: Function -> String -> String -> Bool -> IO Function casadi__Function__jacobian__1 x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__jacobian__1 errStrPtrP x0' x1' x2' x3' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_jacobian__1 :: FunctionClass a => a -> String -> String -> Bool -> IO Function function_jacobian__1 x = casadi__Function__jacobian__1 (castFunction x) -- direct wrapper foreign import ccall safe "casadi__Function__jacobian__2" c_casadi__Function__jacobian__2 :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> Ptr StdString -> CInt -> CInt -> IO (Ptr Function') casadi__Function__jacobian__2 :: Function -> String -> String -> Bool -> Bool -> IO Function casadi__Function__jacobian__2 x0 x1 x2 x3 x4 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> withMarshal x4 $ \x4' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__jacobian__2 errStrPtrP x0' x1' x2' x3' x4' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_jacobian__2 :: FunctionClass a => a -> String -> String -> Bool -> Bool -> IO Function function_jacobian__2 x = casadi__Function__jacobian__2 (castFunction x) -- direct wrapper foreign import ccall safe "casadi__Function__jacobian__3" c_casadi__Function__jacobian__3 :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> Ptr StdString -> IO (Ptr Function') casadi__Function__jacobian__3 :: Function -> Int -> String -> IO Function casadi__Function__jacobian__3 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__jacobian__3 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_jacobian__3 :: FunctionClass a => a -> Int -> String -> IO Function function_jacobian__3 x = casadi__Function__jacobian__3 (castFunction x) -- direct wrapper foreign import ccall safe "casadi__Function__jacobian__4" c_casadi__Function__jacobian__4 :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> Ptr StdString -> CInt -> IO (Ptr Function') casadi__Function__jacobian__4 :: Function -> Int -> String -> Bool -> IO Function casadi__Function__jacobian__4 x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__jacobian__4 errStrPtrP x0' x1' x2' x3' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_jacobian__4 :: FunctionClass a => a -> Int -> String -> Bool -> IO Function function_jacobian__4 x = casadi__Function__jacobian__4 (castFunction x) -- direct wrapper foreign import ccall safe "casadi__Function__jacobian__5" c_casadi__Function__jacobian__5 :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> Ptr StdString -> CInt -> CInt -> IO (Ptr Function') casadi__Function__jacobian__5 :: Function -> Int -> String -> Bool -> Bool -> IO Function casadi__Function__jacobian__5 x0 x1 x2 x3 x4 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> withMarshal x4 $ \x4' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__jacobian__5 errStrPtrP x0' x1' x2' x3' x4' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_jacobian__5 :: FunctionClass a => a -> Int -> String -> Bool -> Bool -> IO Function function_jacobian__5 x = casadi__Function__jacobian__5 (castFunction x) -- direct wrapper foreign import ccall safe "casadi__Function__jacobian__6" c_casadi__Function__jacobian__6 :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO (Ptr Function') casadi__Function__jacobian__6 :: Function -> String -> IO Function casadi__Function__jacobian__6 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__jacobian__6 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_jacobian__6 :: FunctionClass a => a -> String -> IO Function function_jacobian__6 x = casadi__Function__jacobian__6 (castFunction x) -- direct wrapper foreign import ccall safe "casadi__Function__jacobian__7" c_casadi__Function__jacobian__7 :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> CInt -> IO (Ptr Function') casadi__Function__jacobian__7 :: Function -> String -> Int -> IO Function casadi__Function__jacobian__7 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__jacobian__7 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_jacobian__7 :: FunctionClass a => a -> String -> Int -> IO Function function_jacobian__7 x = casadi__Function__jacobian__7 (castFunction x) -- direct wrapper foreign import ccall safe "casadi__Function__jacobian__8" c_casadi__Function__jacobian__8 :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> CInt -> CInt -> IO (Ptr Function') casadi__Function__jacobian__8 :: Function -> String -> Int -> Bool -> IO Function casadi__Function__jacobian__8 x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__jacobian__8 errStrPtrP x0' x1' x2' x3' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_jacobian__8 :: FunctionClass a => a -> String -> Int -> Bool -> IO Function function_jacobian__8 x = casadi__Function__jacobian__8 (castFunction x) -- direct wrapper foreign import ccall safe "casadi__Function__jacobian__9" c_casadi__Function__jacobian__9 :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> CInt -> CInt -> CInt -> IO (Ptr Function') casadi__Function__jacobian__9 :: Function -> String -> Int -> Bool -> Bool -> IO Function casadi__Function__jacobian__9 x0 x1 x2 x3 x4 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> withMarshal x4 $ \x4' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__jacobian__9 errStrPtrP x0' x1' x2' x3' x4' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_jacobian__9 :: FunctionClass a => a -> String -> Int -> Bool -> Bool -> IO Function function_jacobian__9 x = casadi__Function__jacobian__9 (castFunction x) -- direct wrapper foreign import ccall safe "casadi__Function__jacobian__10" c_casadi__Function__jacobian__10 :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr Function') casadi__Function__jacobian__10 :: Function -> IO Function casadi__Function__jacobian__10 x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__jacobian__10 errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_jacobian__10 :: FunctionClass a => a -> IO Function function_jacobian__10 x = casadi__Function__jacobian__10 (castFunction x) -- direct wrapper foreign import ccall safe "casadi__Function__jacobian__11" c_casadi__Function__jacobian__11 :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO (Ptr Function') casadi__Function__jacobian__11 :: Function -> Int -> IO Function casadi__Function__jacobian__11 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__jacobian__11 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_jacobian__11 :: FunctionClass a => a -> Int -> IO Function function_jacobian__11 x = casadi__Function__jacobian__11 (castFunction x) -- direct wrapper foreign import ccall safe "casadi__Function__jacobian__12" c_casadi__Function__jacobian__12 :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> CInt -> IO (Ptr Function') casadi__Function__jacobian__12 :: Function -> Int -> Int -> IO Function casadi__Function__jacobian__12 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__jacobian__12 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_jacobian__12 :: FunctionClass a => a -> Int -> Int -> IO Function function_jacobian__12 x = casadi__Function__jacobian__12 (castFunction x) -- direct wrapper foreign import ccall safe "casadi__Function__jacobian__13" c_casadi__Function__jacobian__13 :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> CInt -> CInt -> IO (Ptr Function') casadi__Function__jacobian__13 :: Function -> Int -> Int -> Bool -> IO Function casadi__Function__jacobian__13 x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__jacobian__13 errStrPtrP x0' x1' x2' x3' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_jacobian__13 :: FunctionClass a => a -> Int -> Int -> Bool -> IO Function function_jacobian__13 x = casadi__Function__jacobian__13 (castFunction x) -- direct wrapper foreign import ccall safe "casadi__Function__jacobian__14" c_casadi__Function__jacobian__14 :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> CInt -> CInt -> CInt -> IO (Ptr Function') casadi__Function__jacobian__14 :: Function -> Int -> Int -> Bool -> Bool -> IO Function casadi__Function__jacobian__14 x0 x1 x2 x3 x4 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> withMarshal x4 $ \x4' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__jacobian__14 errStrPtrP x0' x1' x2' x3' x4' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_jacobian__14 :: FunctionClass a => a -> Int -> Int -> Bool -> Bool -> IO Function function_jacobian__14 x = casadi__Function__jacobian__14 (castFunction x) -- direct wrapper foreign import ccall unsafe "casadi__Function__map__0" c_casadi__Function__map__0 :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> CInt -> IO (Ptr Function') casadi__Function__map__0 :: Function -> String -> Int -> IO Function casadi__Function__map__0 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__map__0 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_map__0 :: FunctionClass a => a -> String -> Int -> IO Function function_map__0 x = casadi__Function__map__0 (castFunction x) -- direct wrapper foreign import ccall unsafe "casadi__Function__map__1" c_casadi__Function__map__1 :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> CInt -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr Function') casadi__Function__map__1 :: Function -> String -> Int -> M.Map String GenericType -> IO Function casadi__Function__map__1 x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__map__1 errStrPtrP x0' x1' x2' x3' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_map__1 :: FunctionClass a => a -> String -> Int -> M.Map String GenericType -> IO Function function_map__1 x = casadi__Function__map__1 (castFunction x) -- direct wrapper foreign import ccall unsafe "casadi__Function__map__2" c_casadi__Function__map__2 :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr MX')) -> IO (Ptr (StdVec (Ptr MX'))) casadi__Function__map__2 :: Function -> Vector MX -> IO (Vector MX) casadi__Function__map__2 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__map__2 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_map__2 :: FunctionClass a => a -> Vector MX -> IO (Vector MX) function_map__2 x = casadi__Function__map__2 (castFunction x) -- direct wrapper foreign import ccall unsafe "casadi__Function__map__3" c_casadi__Function__map__3 :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) casadi__Function__map__3 :: Function -> Vector MX -> String -> IO (Vector MX) casadi__Function__map__3 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__map__3 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_map__3 :: FunctionClass a => a -> Vector MX -> String -> IO (Vector MX) function_map__3 x = casadi__Function__map__3 (castFunction x) -- direct wrapper foreign import ccall unsafe "casadi__Function__map__4" c_casadi__Function__map__4 :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> IO (Ptr (StdVec (Ptr (StdVec (Ptr MX'))))) casadi__Function__map__4 :: Function -> Vector (Vector MX) -> IO (Vector (Vector MX)) casadi__Function__map__4 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__map__4 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_map__4 :: FunctionClass a => a -> Vector (Vector MX) -> IO (Vector (Vector MX)) function_map__4 x = casadi__Function__map__4 (castFunction x) -- direct wrapper foreign import ccall unsafe "casadi__Function__map__5" c_casadi__Function__map__5 :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> Ptr StdString -> IO (Ptr (StdVec (Ptr (StdVec (Ptr MX'))))) casadi__Function__map__5 :: Function -> Vector (Vector MX) -> String -> IO (Vector (Vector MX)) casadi__Function__map__5 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__map__5 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_map__5 :: FunctionClass a => a -> Vector (Vector MX) -> String -> IO (Vector (Vector MX)) function_map__5 x = casadi__Function__map__5 (castFunction x) -- direct wrapper foreign import ccall unsafe "casadi__Function__mapaccum__0" c_casadi__Function__mapaccum__0 :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> CInt -> IO (Ptr Function') casadi__Function__mapaccum__0 :: Function -> String -> Int -> IO Function casadi__Function__mapaccum__0 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__mapaccum__0 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_mapaccum__0 :: FunctionClass a => a -> String -> Int -> IO Function function_mapaccum__0 x = casadi__Function__mapaccum__0 (castFunction x) -- direct wrapper foreign import ccall unsafe "casadi__Function__mapaccum__1" c_casadi__Function__mapaccum__1 :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> CInt -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr Function') casadi__Function__mapaccum__1 :: Function -> String -> Int -> M.Map String GenericType -> IO Function casadi__Function__mapaccum__1 x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__mapaccum__1 errStrPtrP x0' x1' x2' x3' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_mapaccum__1 :: FunctionClass a => a -> String -> Int -> M.Map String GenericType -> IO Function function_mapaccum__1 x = casadi__Function__mapaccum__1 (castFunction x) -- direct wrapper foreign import ccall unsafe "casadi__Function__mapsum__0" c_casadi__Function__mapsum__0 :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr MX')) -> IO (Ptr (StdVec (Ptr MX'))) casadi__Function__mapsum__0 :: Function -> Vector MX -> IO (Vector MX) casadi__Function__mapsum__0 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__mapsum__0 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_mapsum__0 :: FunctionClass a => a -> Vector MX -> IO (Vector MX) function_mapsum__0 x = casadi__Function__mapsum__0 (castFunction x) -- direct wrapper foreign import ccall unsafe "casadi__Function__mapsum__1" c_casadi__Function__mapsum__1 :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) casadi__Function__mapsum__1 :: Function -> Vector MX -> String -> IO (Vector MX) casadi__Function__mapsum__1 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__mapsum__1 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_mapsum__1 :: FunctionClass a => a -> Vector MX -> String -> IO (Vector MX) function_mapsum__1 x = casadi__Function__mapsum__1 (castFunction x) -- direct wrapper foreign import ccall unsafe "casadi__Function__nIn" c_casadi__Function__nIn :: Ptr (Ptr StdString) -> Ptr Function' -> IO CInt casadi__Function__nIn :: Function -> IO Int casadi__Function__nIn x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__nIn errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_nIn :: FunctionClass a => a -> IO Int function_nIn x = casadi__Function__nIn (castFunction x) -- direct wrapper foreign import ccall unsafe "casadi__Function__nOut" c_casadi__Function__nOut :: Ptr (Ptr StdString) -> Ptr Function' -> IO CInt casadi__Function__nOut :: Function -> IO Int casadi__Function__nOut x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__nOut errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_nOut :: FunctionClass a => a -> IO Int function_nOut x = casadi__Function__nOut (castFunction x) -- direct wrapper foreign import ccall unsafe "casadi__Function__nnzIn" c_casadi__Function__nnzIn :: Ptr (Ptr StdString) -> Ptr Function' -> IO CInt casadi__Function__nnzIn :: Function -> IO Int casadi__Function__nnzIn x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__nnzIn errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_nnzIn :: FunctionClass a => a -> IO Int function_nnzIn x = casadi__Function__nnzIn (castFunction x) -- direct wrapper foreign import ccall unsafe "casadi__Function__nnzOut" c_casadi__Function__nnzOut :: Ptr (Ptr StdString) -> Ptr Function' -> IO CInt casadi__Function__nnzOut :: Function -> IO Int casadi__Function__nnzOut x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__nnzOut errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_nnzOut :: FunctionClass a => a -> IO Int function_nnzOut x = casadi__Function__nnzOut (castFunction x) -- direct wrapper foreign import ccall unsafe "casadi__Function__numelIn" c_casadi__Function__numelIn :: Ptr (Ptr StdString) -> Ptr Function' -> IO CInt casadi__Function__numelIn :: Function -> IO Int casadi__Function__numelIn x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__numelIn errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_numelIn :: FunctionClass a => a -> IO Int function_numelIn x = casadi__Function__numelIn (castFunction x) -- direct wrapper foreign import ccall unsafe "casadi__Function__numelOut" c_casadi__Function__numelOut :: Ptr (Ptr StdString) -> Ptr Function' -> IO CInt casadi__Function__numelOut :: Function -> IO Int casadi__Function__numelOut x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__numelOut errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_numelOut :: FunctionClass a => a -> IO Int function_numelOut x = casadi__Function__numelOut (castFunction x) -- direct wrapper foreign import ccall unsafe "casadi__Function__operator_call__0" c_casadi__Function__operator_call__0 :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdMap StdString (Ptr MX')) -> IO (Ptr (StdMap StdString (Ptr MX'))) casadi__Function__operator_call__0 :: Function -> M.Map String MX -> IO (M.Map String MX) casadi__Function__operator_call__0 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__operator_call__0 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_operator_call__0 :: FunctionClass a => a -> M.Map String MX -> IO (M.Map String MX) function_operator_call__0 x = casadi__Function__operator_call__0 (castFunction x) -- direct wrapper foreign import ccall unsafe "casadi__Function__operator_call__1" c_casadi__Function__operator_call__1 :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdMap StdString (Ptr MX')) -> CInt -> IO (Ptr (StdMap StdString (Ptr MX'))) casadi__Function__operator_call__1 :: Function -> M.Map String MX -> Bool -> IO (M.Map String MX) casadi__Function__operator_call__1 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__operator_call__1 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_operator_call__1 :: FunctionClass a => a -> M.Map String MX -> Bool -> IO (M.Map String MX) function_operator_call__1 x = casadi__Function__operator_call__1 (castFunction x) -- direct wrapper foreign import ccall unsafe "casadi__Function__operator_call__2" c_casadi__Function__operator_call__2 :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdMap StdString (Ptr MX')) -> CInt -> CInt -> IO (Ptr (StdMap StdString (Ptr MX'))) casadi__Function__operator_call__2 :: Function -> M.Map String MX -> Bool -> Bool -> IO (M.Map String MX) casadi__Function__operator_call__2 x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__operator_call__2 errStrPtrP x0' x1' x2' x3' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_operator_call__2 :: FunctionClass a => a -> M.Map String MX -> Bool -> Bool -> IO (M.Map String MX) function_operator_call__2 x = casadi__Function__operator_call__2 (castFunction x) -- direct wrapper foreign import ccall unsafe "casadi__Function__operator_call__3" c_casadi__Function__operator_call__3 :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdMap StdString (Ptr SX')) -> IO (Ptr (StdMap StdString (Ptr SX'))) casadi__Function__operator_call__3 :: Function -> M.Map String SX -> IO (M.Map String SX) casadi__Function__operator_call__3 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__operator_call__3 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_operator_call__3 :: FunctionClass a => a -> M.Map String SX -> IO (M.Map String SX) function_operator_call__3 x = casadi__Function__operator_call__3 (castFunction x) -- direct wrapper foreign import ccall unsafe "casadi__Function__operator_call__4" c_casadi__Function__operator_call__4 :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdMap StdString (Ptr SX')) -> CInt -> IO (Ptr (StdMap StdString (Ptr SX'))) casadi__Function__operator_call__4 :: Function -> M.Map String SX -> Bool -> IO (M.Map String SX) casadi__Function__operator_call__4 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__operator_call__4 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_operator_call__4 :: FunctionClass a => a -> M.Map String SX -> Bool -> IO (M.Map String SX) function_operator_call__4 x = casadi__Function__operator_call__4 (castFunction x) -- direct wrapper foreign import ccall unsafe "casadi__Function__operator_call__5" c_casadi__Function__operator_call__5 :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdMap StdString (Ptr SX')) -> CInt -> CInt -> IO (Ptr (StdMap StdString (Ptr SX'))) casadi__Function__operator_call__5 :: Function -> M.Map String SX -> Bool -> Bool -> IO (M.Map String SX) casadi__Function__operator_call__5 x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__operator_call__5 errStrPtrP x0' x1' x2' x3' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_operator_call__5 :: FunctionClass a => a -> M.Map String SX -> Bool -> Bool -> IO (M.Map String SX) function_operator_call__5 x = casadi__Function__operator_call__5 (castFunction x) -- direct wrapper foreign import ccall unsafe "casadi__Function__operator_call__6" c_casadi__Function__operator_call__6 :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdMap StdString (Ptr DMatrix')) -> IO (Ptr (StdMap StdString (Ptr DMatrix'))) casadi__Function__operator_call__6 :: Function -> M.Map String DMatrix -> IO (M.Map String DMatrix) casadi__Function__operator_call__6 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__operator_call__6 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_operator_call__6 :: FunctionClass a => a -> M.Map String DMatrix -> IO (M.Map String DMatrix) function_operator_call__6 x = casadi__Function__operator_call__6 (castFunction x) -- direct wrapper foreign import ccall unsafe "casadi__Function__operator_call__7" c_casadi__Function__operator_call__7 :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdMap StdString (Ptr DMatrix')) -> CInt -> IO (Ptr (StdMap StdString (Ptr DMatrix'))) casadi__Function__operator_call__7 :: Function -> M.Map String DMatrix -> Bool -> IO (M.Map String DMatrix) casadi__Function__operator_call__7 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__operator_call__7 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_operator_call__7 :: FunctionClass a => a -> M.Map String DMatrix -> Bool -> IO (M.Map String DMatrix) function_operator_call__7 x = casadi__Function__operator_call__7 (castFunction x) -- direct wrapper foreign import ccall unsafe "casadi__Function__operator_call__8" c_casadi__Function__operator_call__8 :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdMap StdString (Ptr DMatrix')) -> CInt -> CInt -> IO (Ptr (StdMap StdString (Ptr DMatrix'))) casadi__Function__operator_call__8 :: Function -> M.Map String DMatrix -> Bool -> Bool -> IO (M.Map String DMatrix) casadi__Function__operator_call__8 x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__operator_call__8 errStrPtrP x0' x1' x2' x3' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_operator_call__8 :: FunctionClass a => a -> M.Map String DMatrix -> Bool -> Bool -> IO (M.Map String DMatrix) function_operator_call__8 x = casadi__Function__operator_call__8 (castFunction x) -- direct wrapper foreign import ccall unsafe "casadi__Function__operator_call__9" c_casadi__Function__operator_call__9 :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr MX')) -> IO (Ptr (StdVec (Ptr MX'))) casadi__Function__operator_call__9 :: Function -> Vector MX -> IO (Vector MX) casadi__Function__operator_call__9 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__operator_call__9 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_operator_call__9 :: FunctionClass a => a -> Vector MX -> IO (Vector MX) function_operator_call__9 x = casadi__Function__operator_call__9 (castFunction x) -- direct wrapper foreign import ccall unsafe "casadi__Function__operator_call__10" c_casadi__Function__operator_call__10 :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr MX')) -> CInt -> IO (Ptr (StdVec (Ptr MX'))) casadi__Function__operator_call__10 :: Function -> Vector MX -> Bool -> IO (Vector MX) casadi__Function__operator_call__10 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__operator_call__10 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_operator_call__10 :: FunctionClass a => a -> Vector MX -> Bool -> IO (Vector MX) function_operator_call__10 x = casadi__Function__operator_call__10 (castFunction x) -- direct wrapper foreign import ccall unsafe "casadi__Function__operator_call__11" c_casadi__Function__operator_call__11 :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr MX')) -> CInt -> CInt -> IO (Ptr (StdVec (Ptr MX'))) casadi__Function__operator_call__11 :: Function -> Vector MX -> Bool -> Bool -> IO (Vector MX) casadi__Function__operator_call__11 x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__operator_call__11 errStrPtrP x0' x1' x2' x3' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_operator_call__11 :: FunctionClass a => a -> Vector MX -> Bool -> Bool -> IO (Vector MX) function_operator_call__11 x = casadi__Function__operator_call__11 (castFunction x) -- direct wrapper foreign import ccall unsafe "casadi__Function__operator_call__12" c_casadi__Function__operator_call__12 :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr SX')) -> IO (Ptr (StdVec (Ptr SX'))) casadi__Function__operator_call__12 :: Function -> Vector SX -> IO (Vector SX) casadi__Function__operator_call__12 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__operator_call__12 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_operator_call__12 :: FunctionClass a => a -> Vector SX -> IO (Vector SX) function_operator_call__12 x = casadi__Function__operator_call__12 (castFunction x) -- direct wrapper foreign import ccall unsafe "casadi__Function__operator_call__13" c_casadi__Function__operator_call__13 :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr SX')) -> CInt -> IO (Ptr (StdVec (Ptr SX'))) casadi__Function__operator_call__13 :: Function -> Vector SX -> Bool -> IO (Vector SX) casadi__Function__operator_call__13 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__operator_call__13 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_operator_call__13 :: FunctionClass a => a -> Vector SX -> Bool -> IO (Vector SX) function_operator_call__13 x = casadi__Function__operator_call__13 (castFunction x) -- direct wrapper foreign import ccall unsafe "casadi__Function__operator_call__14" c_casadi__Function__operator_call__14 :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr SX')) -> CInt -> CInt -> IO (Ptr (StdVec (Ptr SX'))) casadi__Function__operator_call__14 :: Function -> Vector SX -> Bool -> Bool -> IO (Vector SX) casadi__Function__operator_call__14 x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__operator_call__14 errStrPtrP x0' x1' x2' x3' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_operator_call__14 :: FunctionClass a => a -> Vector SX -> Bool -> Bool -> IO (Vector SX) function_operator_call__14 x = casadi__Function__operator_call__14 (castFunction x) -- direct wrapper foreign import ccall unsafe "casadi__Function__operator_call__15" c_casadi__Function__operator_call__15 :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr DMatrix')) -> IO (Ptr (StdVec (Ptr DMatrix'))) casadi__Function__operator_call__15 :: Function -> Vector DMatrix -> IO (Vector DMatrix) casadi__Function__operator_call__15 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__operator_call__15 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_operator_call__15 :: FunctionClass a => a -> Vector DMatrix -> IO (Vector DMatrix) function_operator_call__15 x = casadi__Function__operator_call__15 (castFunction x) -- direct wrapper foreign import ccall unsafe "casadi__Function__operator_call__16" c_casadi__Function__operator_call__16 :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr DMatrix')) -> CInt -> IO (Ptr (StdVec (Ptr DMatrix'))) casadi__Function__operator_call__16 :: Function -> Vector DMatrix -> Bool -> IO (Vector DMatrix) casadi__Function__operator_call__16 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__operator_call__16 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_operator_call__16 :: FunctionClass a => a -> Vector DMatrix -> Bool -> IO (Vector DMatrix) function_operator_call__16 x = casadi__Function__operator_call__16 (castFunction x) -- direct wrapper foreign import ccall unsafe "casadi__Function__operator_call__17" c_casadi__Function__operator_call__17 :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr DMatrix')) -> CInt -> CInt -> IO (Ptr (StdVec (Ptr DMatrix'))) casadi__Function__operator_call__17 :: Function -> Vector DMatrix -> Bool -> Bool -> IO (Vector DMatrix) casadi__Function__operator_call__17 x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__operator_call__17 errStrPtrP x0' x1' x2' x3' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_operator_call__17 :: FunctionClass a => a -> Vector DMatrix -> Bool -> Bool -> IO (Vector DMatrix) function_operator_call__17 x = casadi__Function__operator_call__17 (castFunction x) -- direct wrapper foreign import ccall unsafe "casadi__Function__outputDescription" c_casadi__Function__outputDescription :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO (Ptr StdString) casadi__Function__outputDescription :: Function -> Int -> IO String casadi__Function__outputDescription x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__outputDescription errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_outputDescription :: FunctionClass a => a -> Int -> IO String function_outputDescription x = casadi__Function__outputDescription (castFunction x) -- direct wrapper foreign import ccall unsafe "casadi__Function__outputIndex" c_casadi__Function__outputIndex :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO CInt casadi__Function__outputIndex :: Function -> String -> IO Int casadi__Function__outputIndex x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__outputIndex errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_outputIndex :: FunctionClass a => a -> String -> IO Int function_outputIndex x = casadi__Function__outputIndex (castFunction x) -- direct wrapper foreign import ccall unsafe "casadi__Function__outputName" c_casadi__Function__outputName :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO (Ptr StdString) casadi__Function__outputName :: Function -> Int -> IO String casadi__Function__outputName x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__outputName errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_outputName :: FunctionClass a => a -> Int -> IO String function_outputName x = casadi__Function__outputName (castFunction x) -- direct wrapper foreign import ccall unsafe "casadi__Function__outputScheme" c_casadi__Function__outputScheme :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr (StdVec (Ptr StdString))) casadi__Function__outputScheme :: Function -> IO (Vector String) casadi__Function__outputScheme x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__outputScheme errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_outputScheme :: FunctionClass a => a -> IO (Vector String) function_outputScheme x = casadi__Function__outputScheme (castFunction x) -- direct wrapper foreign import ccall unsafe "casadi__Function__outputSparsity__0" c_casadi__Function__outputSparsity__0 :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO (Ptr Sparsity') casadi__Function__outputSparsity__0 :: Function -> String -> IO Sparsity casadi__Function__outputSparsity__0 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__outputSparsity__0 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_outputSparsity__0 :: FunctionClass a => a -> String -> IO Sparsity function_outputSparsity__0 x = casadi__Function__outputSparsity__0 (castFunction x) -- direct wrapper foreign import ccall unsafe "casadi__Function__outputSparsity__1" c_casadi__Function__outputSparsity__1 :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr Sparsity') casadi__Function__outputSparsity__1 :: Function -> IO Sparsity casadi__Function__outputSparsity__1 x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__outputSparsity__1 errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_outputSparsity__1 :: FunctionClass a => a -> IO Sparsity function_outputSparsity__1 x = casadi__Function__outputSparsity__1 (castFunction x) -- direct wrapper foreign import ccall unsafe "casadi__Function__outputSparsity__2" c_casadi__Function__outputSparsity__2 :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO (Ptr Sparsity') casadi__Function__outputSparsity__2 :: Function -> Int -> IO Sparsity casadi__Function__outputSparsity__2 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__outputSparsity__2 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_outputSparsity__2 :: FunctionClass a => a -> Int -> IO Sparsity function_outputSparsity__2 x = casadi__Function__outputSparsity__2 (castFunction x) -- direct wrapper foreign import ccall unsafe "casadi__Function__printDimensions" c_casadi__Function__printDimensions :: Ptr (Ptr StdString) -> Ptr Function' -> IO () casadi__Function__printDimensions :: Function -> IO () casadi__Function__printDimensions x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__printDimensions errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_printDimensions :: FunctionClass a => a -> IO () function_printDimensions x = casadi__Function__printDimensions (castFunction x) -- direct wrapper foreign import ccall unsafe "casadi__Function__removeMonitor" c_casadi__Function__removeMonitor :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO () casadi__Function__removeMonitor :: Function -> String -> IO () casadi__Function__removeMonitor x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__removeMonitor errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_removeMonitor :: FunctionClass a => a -> String -> IO () function_removeMonitor x = casadi__Function__removeMonitor (castFunction x) -- direct wrapper foreign import ccall unsafe "casadi__Function__sanitizeName" c_casadi__Function__sanitizeName :: Ptr (Ptr StdString) -> Ptr StdString -> IO (Ptr StdString) casadi__Function__sanitizeName :: String -> IO String casadi__Function__sanitizeName x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__sanitizeName errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_sanitizeName :: String -> IO String function_sanitizeName = casadi__Function__sanitizeName -- direct wrapper foreign import ccall unsafe "casadi__Function__setDerForward" c_casadi__Function__setDerForward :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr Function' -> CInt -> IO () casadi__Function__setDerForward :: Function -> Function -> Int -> IO () casadi__Function__setDerForward x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__setDerForward errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_setDerForward :: FunctionClass a => a -> Function -> Int -> IO () function_setDerForward x = casadi__Function__setDerForward (castFunction x) -- direct wrapper foreign import ccall unsafe "casadi__Function__setDerReverse" c_casadi__Function__setDerReverse :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr Function' -> CInt -> IO () casadi__Function__setDerReverse :: Function -> Function -> Int -> IO () casadi__Function__setDerReverse x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__setDerReverse errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_setDerReverse :: FunctionClass a => a -> Function -> Int -> IO () function_setDerReverse x = casadi__Function__setDerReverse (castFunction x) -- direct wrapper foreign import ccall unsafe "casadi__Function__setFullJacobian" c_casadi__Function__setFullJacobian :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr Function' -> IO () casadi__Function__setFullJacobian :: Function -> Function -> IO () casadi__Function__setFullJacobian x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__setFullJacobian errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_setFullJacobian :: FunctionClass a => a -> Function -> IO () function_setFullJacobian x = casadi__Function__setFullJacobian (castFunction x) -- direct wrapper foreign import ccall unsafe "casadi__Function__setJacSparsity__0" c_casadi__Function__setJacSparsity__0 :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr Sparsity' -> Ptr StdString -> Ptr StdString -> IO () casadi__Function__setJacSparsity__0 :: Function -> Sparsity -> String -> String -> IO () casadi__Function__setJacSparsity__0 x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__setJacSparsity__0 errStrPtrP x0' x1' x2' x3' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_setJacSparsity__0 :: FunctionClass a => a -> Sparsity -> String -> String -> IO () function_setJacSparsity__0 x = casadi__Function__setJacSparsity__0 (castFunction x) -- direct wrapper foreign import ccall unsafe "casadi__Function__setJacSparsity__1" c_casadi__Function__setJacSparsity__1 :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr Sparsity' -> Ptr StdString -> Ptr StdString -> CInt -> IO () casadi__Function__setJacSparsity__1 :: Function -> Sparsity -> String -> String -> Bool -> IO () casadi__Function__setJacSparsity__1 x0 x1 x2 x3 x4 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> withMarshal x4 $ \x4' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__setJacSparsity__1 errStrPtrP x0' x1' x2' x3' x4' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_setJacSparsity__1 :: FunctionClass a => a -> Sparsity -> String -> String -> Bool -> IO () function_setJacSparsity__1 x = casadi__Function__setJacSparsity__1 (castFunction x) -- direct wrapper foreign import ccall unsafe "casadi__Function__setJacSparsity__2" c_casadi__Function__setJacSparsity__2 :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr Sparsity' -> CInt -> Ptr StdString -> IO () casadi__Function__setJacSparsity__2 :: Function -> Sparsity -> Int -> String -> IO () casadi__Function__setJacSparsity__2 x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__setJacSparsity__2 errStrPtrP x0' x1' x2' x3' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_setJacSparsity__2 :: FunctionClass a => a -> Sparsity -> Int -> String -> IO () function_setJacSparsity__2 x = casadi__Function__setJacSparsity__2 (castFunction x) -- direct wrapper foreign import ccall unsafe "casadi__Function__setJacSparsity__3" c_casadi__Function__setJacSparsity__3 :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr Sparsity' -> CInt -> Ptr StdString -> CInt -> IO () casadi__Function__setJacSparsity__3 :: Function -> Sparsity -> Int -> String -> Bool -> IO () casadi__Function__setJacSparsity__3 x0 x1 x2 x3 x4 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> withMarshal x4 $ \x4' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__setJacSparsity__3 errStrPtrP x0' x1' x2' x3' x4' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_setJacSparsity__3 :: FunctionClass a => a -> Sparsity -> Int -> String -> Bool -> IO () function_setJacSparsity__3 x = casadi__Function__setJacSparsity__3 (castFunction x) -- direct wrapper foreign import ccall unsafe "casadi__Function__setJacSparsity__4" c_casadi__Function__setJacSparsity__4 :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr Sparsity' -> Ptr StdString -> CInt -> IO () casadi__Function__setJacSparsity__4 :: Function -> Sparsity -> String -> Int -> IO () casadi__Function__setJacSparsity__4 x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__setJacSparsity__4 errStrPtrP x0' x1' x2' x3' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_setJacSparsity__4 :: FunctionClass a => a -> Sparsity -> String -> Int -> IO () function_setJacSparsity__4 x = casadi__Function__setJacSparsity__4 (castFunction x) -- direct wrapper foreign import ccall unsafe "casadi__Function__setJacSparsity__5" c_casadi__Function__setJacSparsity__5 :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr Sparsity' -> Ptr StdString -> CInt -> CInt -> IO () casadi__Function__setJacSparsity__5 :: Function -> Sparsity -> String -> Int -> Bool -> IO () casadi__Function__setJacSparsity__5 x0 x1 x2 x3 x4 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> withMarshal x4 $ \x4' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__setJacSparsity__5 errStrPtrP x0' x1' x2' x3' x4' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_setJacSparsity__5 :: FunctionClass a => a -> Sparsity -> String -> Int -> Bool -> IO () function_setJacSparsity__5 x = casadi__Function__setJacSparsity__5 (castFunction x) -- direct wrapper foreign import ccall unsafe "casadi__Function__setJacSparsity__6" c_casadi__Function__setJacSparsity__6 :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr Sparsity' -> CInt -> CInt -> IO () casadi__Function__setJacSparsity__6 :: Function -> Sparsity -> Int -> Int -> IO () casadi__Function__setJacSparsity__6 x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__setJacSparsity__6 errStrPtrP x0' x1' x2' x3' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_setJacSparsity__6 :: FunctionClass a => a -> Sparsity -> Int -> Int -> IO () function_setJacSparsity__6 x = casadi__Function__setJacSparsity__6 (castFunction x) -- direct wrapper foreign import ccall unsafe "casadi__Function__setJacSparsity__7" c_casadi__Function__setJacSparsity__7 :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr Sparsity' -> CInt -> CInt -> CInt -> IO () casadi__Function__setJacSparsity__7 :: Function -> Sparsity -> Int -> Int -> Bool -> IO () casadi__Function__setJacSparsity__7 x0 x1 x2 x3 x4 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> withMarshal x4 $ \x4' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__setJacSparsity__7 errStrPtrP x0' x1' x2' x3' x4' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_setJacSparsity__7 :: FunctionClass a => a -> Sparsity -> Int -> Int -> Bool -> IO () function_setJacSparsity__7 x = casadi__Function__setJacSparsity__7 (castFunction x) -- direct wrapper foreign import ccall unsafe "casadi__Function__setJacobian__0" c_casadi__Function__setJacobian__0 :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr Function' -> IO () casadi__Function__setJacobian__0 :: Function -> Function -> IO () casadi__Function__setJacobian__0 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__setJacobian__0 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_setJacobian__0 :: FunctionClass a => a -> Function -> IO () function_setJacobian__0 x = casadi__Function__setJacobian__0 (castFunction x) -- direct wrapper foreign import ccall unsafe "casadi__Function__setJacobian__1" c_casadi__Function__setJacobian__1 :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr Function' -> CInt -> IO () casadi__Function__setJacobian__1 :: Function -> Function -> Int -> IO () casadi__Function__setJacobian__1 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__setJacobian__1 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_setJacobian__1 :: FunctionClass a => a -> Function -> Int -> IO () function_setJacobian__1 x = casadi__Function__setJacobian__1 (castFunction x) -- direct wrapper foreign import ccall unsafe "casadi__Function__setJacobian__2" c_casadi__Function__setJacobian__2 :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr Function' -> CInt -> CInt -> IO () casadi__Function__setJacobian__2 :: Function -> Function -> Int -> Int -> IO () casadi__Function__setJacobian__2 x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__setJacobian__2 errStrPtrP x0' x1' x2' x3' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_setJacobian__2 :: FunctionClass a => a -> Function -> Int -> Int -> IO () function_setJacobian__2 x = casadi__Function__setJacobian__2 (castFunction x) -- direct wrapper foreign import ccall unsafe "casadi__Function__setJacobian__3" c_casadi__Function__setJacobian__3 :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr Function' -> CInt -> CInt -> CInt -> IO () casadi__Function__setJacobian__3 :: Function -> Function -> Int -> Int -> Bool -> IO () casadi__Function__setJacobian__3 x0 x1 x2 x3 x4 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> withMarshal x4 $ \x4' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__setJacobian__3 errStrPtrP x0' x1' x2' x3' x4' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_setJacobian__3 :: FunctionClass a => a -> Function -> Int -> Int -> Bool -> IO () function_setJacobian__3 x = casadi__Function__setJacobian__3 (castFunction x) -- direct wrapper foreign import ccall unsafe "casadi__Function__spCanEvaluate" c_casadi__Function__spCanEvaluate :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO CInt casadi__Function__spCanEvaluate :: Function -> Bool -> IO Bool casadi__Function__spCanEvaluate x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__spCanEvaluate errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_spCanEvaluate :: FunctionClass a => a -> Bool -> IO Bool function_spCanEvaluate x = casadi__Function__spCanEvaluate (castFunction x) -- direct wrapper foreign import ccall unsafe "casadi__Function__spEvaluate" c_casadi__Function__spEvaluate :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO () casadi__Function__spEvaluate :: Function -> Bool -> IO () casadi__Function__spEvaluate x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__spEvaluate errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_spEvaluate :: FunctionClass a => a -> Bool -> IO () function_spEvaluate x = casadi__Function__spEvaluate (castFunction x) -- direct wrapper foreign import ccall unsafe "casadi__Function__spInit" c_casadi__Function__spInit :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO () casadi__Function__spInit :: Function -> Bool -> IO () casadi__Function__spInit x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__spInit errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_spInit :: FunctionClass a => a -> Bool -> IO () function_spInit x = casadi__Function__spInit (castFunction x) -- direct wrapper foreign import ccall unsafe "casadi__Function__symbolicInput__0" c_casadi__Function__symbolicInput__0 :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr (StdVec (Ptr MX'))) casadi__Function__symbolicInput__0 :: Function -> IO (Vector MX) casadi__Function__symbolicInput__0 x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__symbolicInput__0 errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_symbolicInput__0 :: FunctionClass a => a -> IO (Vector MX) function_symbolicInput__0 x = casadi__Function__symbolicInput__0 (castFunction x) -- direct wrapper foreign import ccall unsafe "casadi__Function__symbolicInput__1" c_casadi__Function__symbolicInput__1 :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO (Ptr (StdVec (Ptr MX'))) casadi__Function__symbolicInput__1 :: Function -> Bool -> IO (Vector MX) casadi__Function__symbolicInput__1 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__symbolicInput__1 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_symbolicInput__1 :: FunctionClass a => a -> Bool -> IO (Vector MX) function_symbolicInput__1 x = casadi__Function__symbolicInput__1 (castFunction x) -- direct wrapper foreign import ccall unsafe "casadi__Function__symbolicInputSX" c_casadi__Function__symbolicInputSX :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr (StdVec (Ptr SX'))) casadi__Function__symbolicInputSX :: Function -> IO (Vector SX) casadi__Function__symbolicInputSX x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__symbolicInputSX errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_symbolicInputSX :: FunctionClass a => a -> IO (Vector SX) function_symbolicInputSX x = casadi__Function__symbolicInputSX (castFunction x) -- direct wrapper foreign import ccall unsafe "casadi__Function__symbolicOutput" c_casadi__Function__symbolicOutput :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr (StdVec (Ptr MX'))) casadi__Function__symbolicOutput :: Function -> IO (Vector MX) casadi__Function__symbolicOutput x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__symbolicOutput errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_symbolicOutput :: FunctionClass a => a -> IO (Vector MX) function_symbolicOutput x = casadi__Function__symbolicOutput (castFunction x) -- direct wrapper foreign import ccall unsafe "casadi__Function__sz_arg" c_casadi__Function__sz_arg :: Ptr (Ptr StdString) -> Ptr Function' -> IO CSize casadi__Function__sz_arg :: Function -> IO CSize casadi__Function__sz_arg x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__sz_arg errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_sz_arg :: FunctionClass a => a -> IO CSize function_sz_arg x = casadi__Function__sz_arg (castFunction x) -- direct wrapper foreign import ccall unsafe "casadi__Function__sz_iw" c_casadi__Function__sz_iw :: Ptr (Ptr StdString) -> Ptr Function' -> IO CSize casadi__Function__sz_iw :: Function -> IO CSize casadi__Function__sz_iw x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__sz_iw errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_sz_iw :: FunctionClass a => a -> IO CSize function_sz_iw x = casadi__Function__sz_iw (castFunction x) -- direct wrapper foreign import ccall unsafe "casadi__Function__sz_res" c_casadi__Function__sz_res :: Ptr (Ptr StdString) -> Ptr Function' -> IO CSize casadi__Function__sz_res :: Function -> IO CSize casadi__Function__sz_res x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__sz_res errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_sz_res :: FunctionClass a => a -> IO CSize function_sz_res x = casadi__Function__sz_res (castFunction x) -- direct wrapper foreign import ccall unsafe "casadi__Function__sz_w" c_casadi__Function__sz_w :: Ptr (Ptr StdString) -> Ptr Function' -> IO CSize casadi__Function__sz_w :: Function -> IO CSize casadi__Function__sz_w x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__sz_w errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_sz_w :: FunctionClass a => a -> IO CSize function_sz_w x = casadi__Function__sz_w (castFunction x) -- direct wrapper foreign import ccall safe "casadi__Function__tangent__0" c_casadi__Function__tangent__0 :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> Ptr StdString -> IO (Ptr Function') casadi__Function__tangent__0 :: Function -> String -> String -> IO Function casadi__Function__tangent__0 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__tangent__0 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_tangent__0 :: FunctionClass a => a -> String -> String -> IO Function function_tangent__0 x = casadi__Function__tangent__0 (castFunction x) -- direct wrapper foreign import ccall safe "casadi__Function__tangent__1" c_casadi__Function__tangent__1 :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> Ptr StdString -> IO (Ptr Function') casadi__Function__tangent__1 :: Function -> Int -> String -> IO Function casadi__Function__tangent__1 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__tangent__1 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_tangent__1 :: FunctionClass a => a -> Int -> String -> IO Function function_tangent__1 x = casadi__Function__tangent__1 (castFunction x) -- direct wrapper foreign import ccall safe "casadi__Function__tangent__2" c_casadi__Function__tangent__2 :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO (Ptr Function') casadi__Function__tangent__2 :: Function -> String -> IO Function casadi__Function__tangent__2 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__tangent__2 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_tangent__2 :: FunctionClass a => a -> String -> IO Function function_tangent__2 x = casadi__Function__tangent__2 (castFunction x) -- direct wrapper foreign import ccall safe "casadi__Function__tangent__3" c_casadi__Function__tangent__3 :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> CInt -> IO (Ptr Function') casadi__Function__tangent__3 :: Function -> String -> Int -> IO Function casadi__Function__tangent__3 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__tangent__3 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_tangent__3 :: FunctionClass a => a -> String -> Int -> IO Function function_tangent__3 x = casadi__Function__tangent__3 (castFunction x) -- direct wrapper foreign import ccall safe "casadi__Function__tangent__4" c_casadi__Function__tangent__4 :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr Function') casadi__Function__tangent__4 :: Function -> IO Function casadi__Function__tangent__4 x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__tangent__4 errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_tangent__4 :: FunctionClass a => a -> IO Function function_tangent__4 x = casadi__Function__tangent__4 (castFunction x) -- direct wrapper foreign import ccall safe "casadi__Function__tangent__5" c_casadi__Function__tangent__5 :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO (Ptr Function') casadi__Function__tangent__5 :: Function -> Int -> IO Function casadi__Function__tangent__5 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__tangent__5 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_tangent__5 :: FunctionClass a => a -> Int -> IO Function function_tangent__5 x = casadi__Function__tangent__5 (castFunction x) -- direct wrapper foreign import ccall safe "casadi__Function__tangent__6" c_casadi__Function__tangent__6 :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> CInt -> IO (Ptr Function') casadi__Function__tangent__6 :: Function -> Int -> Int -> IO Function casadi__Function__tangent__6 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__Function__tangent__6 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper function_tangent__6 :: FunctionClass a => a -> Int -> Int -> IO Function function_tangent__6 x = casadi__Function__tangent__6 (castFunction x)