SymbolicOCP.hs

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

module Casadi.Core.Classes.SymbolicOCP
       (
         SymbolicOCP,
         SymbolicOCPClass(..),
         symbolicOCP,
         symbolicOCP_addVariable__0,
         symbolicOCP_addVariable__1,
         symbolicOCP_add_alg,
         symbolicOCP_add_dae,
         symbolicOCP_add_ode,
         symbolicOCP_add_p,
         symbolicOCP_add_u,
         symbolicOCP_add_x,
         symbolicOCP_add_z,
         symbolicOCP_der__0,
         symbolicOCP_der__1,
         symbolicOCP_derivativeStart__0,
         symbolicOCP_derivativeStart__1,
         symbolicOCP_derivativeStart__2,
         symbolicOCP_derivativeStart__3,
         symbolicOCP_eliminate_alg,
         symbolicOCP_eliminate_i,
         symbolicOCP_eliminate_lterm,
         symbolicOCP_eliminate_quad,
         symbolicOCP_generateCode,
         symbolicOCP_generateHeader__0,
         symbolicOCP_generateHeader__1,
         symbolicOCP_generateMuscodDatFile,
         symbolicOCP_getDescription,
         symbolicOCP_getRepresentation,
         symbolicOCP_initialGuess__0,
         symbolicOCP_initialGuess__1,
         symbolicOCP_initialGuess__2,
         symbolicOCP_initialGuess__3,
         symbolicOCP_makeExplicit,
         symbolicOCP_makeSemiExplicit,
         symbolicOCP_max__0,
         symbolicOCP_max__1,
         symbolicOCP_max__2,
         symbolicOCP_max__3,
         symbolicOCP_min__0,
         symbolicOCP_min__1,
         symbolicOCP_min__2,
         symbolicOCP_min__3,
         symbolicOCP_nominal__0,
         symbolicOCP_nominal__1,
         symbolicOCP_operator_call,
         symbolicOCP_parseFMI,
         symbolicOCP_sanityCheck,
         symbolicOCP_scaleEquations,
         symbolicOCP_scaleVariables,
         symbolicOCP_setDerivativeStart__0,
         symbolicOCP_setDerivativeStart__1,
         symbolicOCP_setDerivativeStart__2,
         symbolicOCP_setDerivativeStart__3,
         symbolicOCP_setInitialGuess__0,
         symbolicOCP_setInitialGuess__1,
         symbolicOCP_setInitialGuess__2,
         symbolicOCP_setInitialGuess__3,
         symbolicOCP_setMax__0,
         symbolicOCP_setMax__1,
         symbolicOCP_setMax__2,
         symbolicOCP_setMax__3,
         symbolicOCP_setMin__0,
         symbolicOCP_setMin__1,
         symbolicOCP_setMin__2,
         symbolicOCP_setMin__3,
         symbolicOCP_setNominal__0,
         symbolicOCP_setNominal__1,
         symbolicOCP_setStart__0,
         symbolicOCP_setStart__1,
         symbolicOCP_setStart__2,
         symbolicOCP_setStart__3,
         symbolicOCP_setUnit,
         symbolicOCP_sort_alg,
         symbolicOCP_sort_dae,
         symbolicOCP_sort_i,
         symbolicOCP_split_dae,
         symbolicOCP_split_i,
         symbolicOCP_start__0,
         symbolicOCP_start__1,
         symbolicOCP_start__2,
         symbolicOCP_start__3,
         symbolicOCP_unit__0,
         symbolicOCP_unit__1,
         symbolicOCP_variable__0,
         symbolicOCP_variable__1,
       ) where


import Prelude hiding ( Functor )

import Data.Vector ( Vector )
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.CToolsInstances ( )
import Casadi.Internal.FormatException ( formatException )
import Casadi.Internal.MarshalTypes ( StdVec, StdString) -- 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__SymbolicOCP__CONSTRUCTOR" c_casadi__SymbolicOCP__CONSTRUCTOR
  :: Ptr (Ptr StdString) -> IO (Ptr SymbolicOCP')
casadi__SymbolicOCP__CONSTRUCTOR
  :: IO SymbolicOCP
casadi__SymbolicOCP__CONSTRUCTOR  =

  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SymbolicOCP__CONSTRUCTOR errStrPtrP 
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
symbolicOCP :: IO SymbolicOCP
symbolicOCP = casadi__SymbolicOCP__CONSTRUCTOR


-- direct wrapper
foreign import ccall unsafe "casadi__SymbolicOCP__addVariable__0" c_casadi__SymbolicOCP__addVariable__0
  :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr StdString -> IO (Ptr SX')
casadi__SymbolicOCP__addVariable__0
  :: SymbolicOCP -> String -> IO SX
casadi__SymbolicOCP__addVariable__0 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SymbolicOCP__addVariable__0 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
symbolicOCP_addVariable__0 :: SymbolicOCPClass a => a -> String -> IO SX
symbolicOCP_addVariable__0 x = casadi__SymbolicOCP__addVariable__0 (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "casadi__SymbolicOCP__addVariable__1" c_casadi__SymbolicOCP__addVariable__1
  :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr StdString -> Ptr Variable' -> IO ()
casadi__SymbolicOCP__addVariable__1
  :: SymbolicOCP -> String -> Variable -> IO ()
casadi__SymbolicOCP__addVariable__1 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SymbolicOCP__addVariable__1 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
symbolicOCP_addVariable__1 :: SymbolicOCPClass a => a -> String -> Variable -> IO ()
symbolicOCP_addVariable__1 x = casadi__SymbolicOCP__addVariable__1 (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "casadi__SymbolicOCP__add_alg" c_casadi__SymbolicOCP__add_alg
  :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr SX' -> IO ()
casadi__SymbolicOCP__add_alg
  :: SymbolicOCP -> SX -> IO ()
casadi__SymbolicOCP__add_alg x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SymbolicOCP__add_alg errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
symbolicOCP_add_alg :: SymbolicOCPClass a => a -> SX -> IO ()
symbolicOCP_add_alg x = casadi__SymbolicOCP__add_alg (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "casadi__SymbolicOCP__add_dae" c_casadi__SymbolicOCP__add_dae
  :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr SX' -> IO ()
casadi__SymbolicOCP__add_dae
  :: SymbolicOCP -> SX -> IO ()
casadi__SymbolicOCP__add_dae x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SymbolicOCP__add_dae errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
symbolicOCP_add_dae :: SymbolicOCPClass a => a -> SX -> IO ()
symbolicOCP_add_dae x = casadi__SymbolicOCP__add_dae (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "casadi__SymbolicOCP__add_ode" c_casadi__SymbolicOCP__add_ode
  :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr SX' -> IO ()
casadi__SymbolicOCP__add_ode
  :: SymbolicOCP -> SX -> IO ()
casadi__SymbolicOCP__add_ode x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SymbolicOCP__add_ode errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
symbolicOCP_add_ode :: SymbolicOCPClass a => a -> SX -> IO ()
symbolicOCP_add_ode x = casadi__SymbolicOCP__add_ode (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "casadi__SymbolicOCP__add_p" c_casadi__SymbolicOCP__add_p
  :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr StdString -> IO (Ptr SX')
casadi__SymbolicOCP__add_p
  :: SymbolicOCP -> String -> IO SX
casadi__SymbolicOCP__add_p x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SymbolicOCP__add_p errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
symbolicOCP_add_p :: SymbolicOCPClass a => a -> String -> IO SX
symbolicOCP_add_p x = casadi__SymbolicOCP__add_p (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "casadi__SymbolicOCP__add_u" c_casadi__SymbolicOCP__add_u
  :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr StdString -> IO (Ptr SX')
casadi__SymbolicOCP__add_u
  :: SymbolicOCP -> String -> IO SX
casadi__SymbolicOCP__add_u x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SymbolicOCP__add_u errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
symbolicOCP_add_u :: SymbolicOCPClass a => a -> String -> IO SX
symbolicOCP_add_u x = casadi__SymbolicOCP__add_u (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "casadi__SymbolicOCP__add_x" c_casadi__SymbolicOCP__add_x
  :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr StdString -> IO (Ptr SX')
casadi__SymbolicOCP__add_x
  :: SymbolicOCP -> String -> IO SX
casadi__SymbolicOCP__add_x x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SymbolicOCP__add_x errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
symbolicOCP_add_x :: SymbolicOCPClass a => a -> String -> IO SX
symbolicOCP_add_x x = casadi__SymbolicOCP__add_x (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "casadi__SymbolicOCP__add_z" c_casadi__SymbolicOCP__add_z
  :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr StdString -> IO (Ptr SX')
casadi__SymbolicOCP__add_z
  :: SymbolicOCP -> String -> IO SX
casadi__SymbolicOCP__add_z x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SymbolicOCP__add_z errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
symbolicOCP_add_z :: SymbolicOCPClass a => a -> String -> IO SX
symbolicOCP_add_z x = casadi__SymbolicOCP__add_z (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "casadi__SymbolicOCP__der__0" c_casadi__SymbolicOCP__der__0
  :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr SX' -> IO (Ptr SX')
casadi__SymbolicOCP__der__0
  :: SymbolicOCP -> SX -> IO SX
casadi__SymbolicOCP__der__0 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SymbolicOCP__der__0 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
symbolicOCP_der__0 :: SymbolicOCPClass a => a -> SX -> IO SX
symbolicOCP_der__0 x = casadi__SymbolicOCP__der__0 (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "casadi__SymbolicOCP__der__1" c_casadi__SymbolicOCP__der__1
  :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr StdString -> IO (Ptr SX')
casadi__SymbolicOCP__der__1
  :: SymbolicOCP -> String -> IO SX
casadi__SymbolicOCP__der__1 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SymbolicOCP__der__1 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
symbolicOCP_der__1 :: SymbolicOCPClass a => a -> String -> IO SX
symbolicOCP_der__1 x = casadi__SymbolicOCP__der__1 (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "casadi__SymbolicOCP__derivativeStart__0" c_casadi__SymbolicOCP__derivativeStart__0
  :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr SX' -> IO (Ptr (StdVec CDouble))
casadi__SymbolicOCP__derivativeStart__0
  :: SymbolicOCP -> SX -> IO (Vector Double)
casadi__SymbolicOCP__derivativeStart__0 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SymbolicOCP__derivativeStart__0 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
symbolicOCP_derivativeStart__0 :: SymbolicOCPClass a => a -> SX -> IO (Vector Double)
symbolicOCP_derivativeStart__0 x = casadi__SymbolicOCP__derivativeStart__0 (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "casadi__SymbolicOCP__derivativeStart__1" c_casadi__SymbolicOCP__derivativeStart__1
  :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr SX' -> CInt -> IO (Ptr (StdVec CDouble))
casadi__SymbolicOCP__derivativeStart__1
  :: SymbolicOCP -> SX -> Bool -> IO (Vector Double)
casadi__SymbolicOCP__derivativeStart__1 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SymbolicOCP__derivativeStart__1 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
symbolicOCP_derivativeStart__1 :: SymbolicOCPClass a => a -> SX -> Bool -> IO (Vector Double)
symbolicOCP_derivativeStart__1 x = casadi__SymbolicOCP__derivativeStart__1 (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "casadi__SymbolicOCP__derivativeStart__2" c_casadi__SymbolicOCP__derivativeStart__2
  :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr StdString -> IO CDouble
casadi__SymbolicOCP__derivativeStart__2
  :: SymbolicOCP -> String -> IO Double
casadi__SymbolicOCP__derivativeStart__2 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SymbolicOCP__derivativeStart__2 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
symbolicOCP_derivativeStart__2 :: SymbolicOCPClass a => a -> String -> IO Double
symbolicOCP_derivativeStart__2 x = casadi__SymbolicOCP__derivativeStart__2 (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "casadi__SymbolicOCP__derivativeStart__3" c_casadi__SymbolicOCP__derivativeStart__3
  :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr StdString -> CInt -> IO CDouble
casadi__SymbolicOCP__derivativeStart__3
  :: SymbolicOCP -> String -> Bool -> IO Double
casadi__SymbolicOCP__derivativeStart__3 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SymbolicOCP__derivativeStart__3 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
symbolicOCP_derivativeStart__3 :: SymbolicOCPClass a => a -> String -> Bool -> IO Double
symbolicOCP_derivativeStart__3 x = casadi__SymbolicOCP__derivativeStart__3 (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "casadi__SymbolicOCP__eliminate_alg" c_casadi__SymbolicOCP__eliminate_alg
  :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> IO ()
casadi__SymbolicOCP__eliminate_alg
  :: SymbolicOCP -> IO ()
casadi__SymbolicOCP__eliminate_alg x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SymbolicOCP__eliminate_alg errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
symbolicOCP_eliminate_alg :: SymbolicOCPClass a => a -> IO ()
symbolicOCP_eliminate_alg x = casadi__SymbolicOCP__eliminate_alg (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "casadi__SymbolicOCP__eliminate_i" c_casadi__SymbolicOCP__eliminate_i
  :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> IO ()
casadi__SymbolicOCP__eliminate_i
  :: SymbolicOCP -> IO ()
casadi__SymbolicOCP__eliminate_i x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SymbolicOCP__eliminate_i errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
symbolicOCP_eliminate_i :: SymbolicOCPClass a => a -> IO ()
symbolicOCP_eliminate_i x = casadi__SymbolicOCP__eliminate_i (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "casadi__SymbolicOCP__eliminate_lterm" c_casadi__SymbolicOCP__eliminate_lterm
  :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> IO ()
casadi__SymbolicOCP__eliminate_lterm
  :: SymbolicOCP -> IO ()
casadi__SymbolicOCP__eliminate_lterm x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SymbolicOCP__eliminate_lterm errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
symbolicOCP_eliminate_lterm :: SymbolicOCPClass a => a -> IO ()
symbolicOCP_eliminate_lterm x = casadi__SymbolicOCP__eliminate_lterm (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "casadi__SymbolicOCP__eliminate_quad" c_casadi__SymbolicOCP__eliminate_quad
  :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> IO ()
casadi__SymbolicOCP__eliminate_quad
  :: SymbolicOCP -> IO ()
casadi__SymbolicOCP__eliminate_quad x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SymbolicOCP__eliminate_quad errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
symbolicOCP_eliminate_quad :: SymbolicOCPClass a => a -> IO ()
symbolicOCP_eliminate_quad x = casadi__SymbolicOCP__eliminate_quad (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "casadi__SymbolicOCP__generateCode" c_casadi__SymbolicOCP__generateCode
  :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr StdString -> IO ()
casadi__SymbolicOCP__generateCode
  :: SymbolicOCP -> String -> IO ()
casadi__SymbolicOCP__generateCode x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SymbolicOCP__generateCode errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
symbolicOCP_generateCode :: SymbolicOCPClass a => a -> String -> IO ()
symbolicOCP_generateCode x = casadi__SymbolicOCP__generateCode (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "casadi__SymbolicOCP__generateHeader__0" c_casadi__SymbolicOCP__generateHeader__0
  :: Ptr (Ptr StdString) -> Ptr StdString -> IO ()
casadi__SymbolicOCP__generateHeader__0
  :: String -> IO ()
casadi__SymbolicOCP__generateHeader__0 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SymbolicOCP__generateHeader__0 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
symbolicOCP_generateHeader__0 :: String -> IO ()
symbolicOCP_generateHeader__0 = casadi__SymbolicOCP__generateHeader__0


-- direct wrapper
foreign import ccall unsafe "casadi__SymbolicOCP__generateHeader__1" c_casadi__SymbolicOCP__generateHeader__1
  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> IO ()
casadi__SymbolicOCP__generateHeader__1
  :: String -> String -> IO ()
casadi__SymbolicOCP__generateHeader__1 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SymbolicOCP__generateHeader__1 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
symbolicOCP_generateHeader__1 :: String -> String -> IO ()
symbolicOCP_generateHeader__1 = casadi__SymbolicOCP__generateHeader__1


-- direct wrapper
foreign import ccall unsafe "casadi__SymbolicOCP__generateMuscodDatFile" c_casadi__SymbolicOCP__generateMuscodDatFile
  :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr StdString -> IO ()
casadi__SymbolicOCP__generateMuscodDatFile
  :: SymbolicOCP -> String -> IO ()
casadi__SymbolicOCP__generateMuscodDatFile x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SymbolicOCP__generateMuscodDatFile errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
symbolicOCP_generateMuscodDatFile :: SymbolicOCPClass a => a -> String -> IO ()
symbolicOCP_generateMuscodDatFile x = casadi__SymbolicOCP__generateMuscodDatFile (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "casadi__SymbolicOCP__initialGuess__0" c_casadi__SymbolicOCP__initialGuess__0
  :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr SX' -> IO (Ptr (StdVec CDouble))
casadi__SymbolicOCP__initialGuess__0
  :: SymbolicOCP -> SX -> IO (Vector Double)
casadi__SymbolicOCP__initialGuess__0 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SymbolicOCP__initialGuess__0 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
symbolicOCP_initialGuess__0 :: SymbolicOCPClass a => a -> SX -> IO (Vector Double)
symbolicOCP_initialGuess__0 x = casadi__SymbolicOCP__initialGuess__0 (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "casadi__SymbolicOCP__initialGuess__1" c_casadi__SymbolicOCP__initialGuess__1
  :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr SX' -> CInt -> IO (Ptr (StdVec CDouble))
casadi__SymbolicOCP__initialGuess__1
  :: SymbolicOCP -> SX -> Bool -> IO (Vector Double)
casadi__SymbolicOCP__initialGuess__1 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SymbolicOCP__initialGuess__1 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
symbolicOCP_initialGuess__1 :: SymbolicOCPClass a => a -> SX -> Bool -> IO (Vector Double)
symbolicOCP_initialGuess__1 x = casadi__SymbolicOCP__initialGuess__1 (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "casadi__SymbolicOCP__initialGuess__2" c_casadi__SymbolicOCP__initialGuess__2
  :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr StdString -> IO CDouble
casadi__SymbolicOCP__initialGuess__2
  :: SymbolicOCP -> String -> IO Double
casadi__SymbolicOCP__initialGuess__2 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SymbolicOCP__initialGuess__2 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
symbolicOCP_initialGuess__2 :: SymbolicOCPClass a => a -> String -> IO Double
symbolicOCP_initialGuess__2 x = casadi__SymbolicOCP__initialGuess__2 (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "casadi__SymbolicOCP__initialGuess__3" c_casadi__SymbolicOCP__initialGuess__3
  :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr StdString -> CInt -> IO CDouble
casadi__SymbolicOCP__initialGuess__3
  :: SymbolicOCP -> String -> Bool -> IO Double
casadi__SymbolicOCP__initialGuess__3 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SymbolicOCP__initialGuess__3 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
symbolicOCP_initialGuess__3 :: SymbolicOCPClass a => a -> String -> Bool -> IO Double
symbolicOCP_initialGuess__3 x = casadi__SymbolicOCP__initialGuess__3 (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "casadi__SymbolicOCP__makeExplicit" c_casadi__SymbolicOCP__makeExplicit
  :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> IO ()
casadi__SymbolicOCP__makeExplicit
  :: SymbolicOCP -> IO ()
casadi__SymbolicOCP__makeExplicit x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SymbolicOCP__makeExplicit errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
symbolicOCP_makeExplicit :: SymbolicOCPClass a => a -> IO ()
symbolicOCP_makeExplicit x = casadi__SymbolicOCP__makeExplicit (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "casadi__SymbolicOCP__makeSemiExplicit" c_casadi__SymbolicOCP__makeSemiExplicit
  :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> IO ()
casadi__SymbolicOCP__makeSemiExplicit
  :: SymbolicOCP -> IO ()
casadi__SymbolicOCP__makeSemiExplicit x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SymbolicOCP__makeSemiExplicit errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
symbolicOCP_makeSemiExplicit :: SymbolicOCPClass a => a -> IO ()
symbolicOCP_makeSemiExplicit x = casadi__SymbolicOCP__makeSemiExplicit (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "casadi__SymbolicOCP__max__0" c_casadi__SymbolicOCP__max__0
  :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr SX' -> IO (Ptr (StdVec CDouble))
casadi__SymbolicOCP__max__0
  :: SymbolicOCP -> SX -> IO (Vector Double)
casadi__SymbolicOCP__max__0 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SymbolicOCP__max__0 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
symbolicOCP_max__0 :: SymbolicOCPClass a => a -> SX -> IO (Vector Double)
symbolicOCP_max__0 x = casadi__SymbolicOCP__max__0 (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "casadi__SymbolicOCP__max__1" c_casadi__SymbolicOCP__max__1
  :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr SX' -> CInt -> IO (Ptr (StdVec CDouble))
casadi__SymbolicOCP__max__1
  :: SymbolicOCP -> SX -> Bool -> IO (Vector Double)
casadi__SymbolicOCP__max__1 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SymbolicOCP__max__1 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
symbolicOCP_max__1 :: SymbolicOCPClass a => a -> SX -> Bool -> IO (Vector Double)
symbolicOCP_max__1 x = casadi__SymbolicOCP__max__1 (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "casadi__SymbolicOCP__max__2" c_casadi__SymbolicOCP__max__2
  :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr StdString -> IO CDouble
casadi__SymbolicOCP__max__2
  :: SymbolicOCP -> String -> IO Double
casadi__SymbolicOCP__max__2 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SymbolicOCP__max__2 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
symbolicOCP_max__2 :: SymbolicOCPClass a => a -> String -> IO Double
symbolicOCP_max__2 x = casadi__SymbolicOCP__max__2 (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "casadi__SymbolicOCP__max__3" c_casadi__SymbolicOCP__max__3
  :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr StdString -> CInt -> IO CDouble
casadi__SymbolicOCP__max__3
  :: SymbolicOCP -> String -> Bool -> IO Double
casadi__SymbolicOCP__max__3 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SymbolicOCP__max__3 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
symbolicOCP_max__3 :: SymbolicOCPClass a => a -> String -> Bool -> IO Double
symbolicOCP_max__3 x = casadi__SymbolicOCP__max__3 (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "casadi__SymbolicOCP__min__0" c_casadi__SymbolicOCP__min__0
  :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr SX' -> IO (Ptr (StdVec CDouble))
casadi__SymbolicOCP__min__0
  :: SymbolicOCP -> SX -> IO (Vector Double)
casadi__SymbolicOCP__min__0 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SymbolicOCP__min__0 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
symbolicOCP_min__0 :: SymbolicOCPClass a => a -> SX -> IO (Vector Double)
symbolicOCP_min__0 x = casadi__SymbolicOCP__min__0 (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "casadi__SymbolicOCP__min__1" c_casadi__SymbolicOCP__min__1
  :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr SX' -> CInt -> IO (Ptr (StdVec CDouble))
casadi__SymbolicOCP__min__1
  :: SymbolicOCP -> SX -> Bool -> IO (Vector Double)
casadi__SymbolicOCP__min__1 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SymbolicOCP__min__1 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
symbolicOCP_min__1 :: SymbolicOCPClass a => a -> SX -> Bool -> IO (Vector Double)
symbolicOCP_min__1 x = casadi__SymbolicOCP__min__1 (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "casadi__SymbolicOCP__min__2" c_casadi__SymbolicOCP__min__2
  :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr StdString -> IO CDouble
casadi__SymbolicOCP__min__2
  :: SymbolicOCP -> String -> IO Double
casadi__SymbolicOCP__min__2 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SymbolicOCP__min__2 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
symbolicOCP_min__2 :: SymbolicOCPClass a => a -> String -> IO Double
symbolicOCP_min__2 x = casadi__SymbolicOCP__min__2 (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "casadi__SymbolicOCP__min__3" c_casadi__SymbolicOCP__min__3
  :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr StdString -> CInt -> IO CDouble
casadi__SymbolicOCP__min__3
  :: SymbolicOCP -> String -> Bool -> IO Double
casadi__SymbolicOCP__min__3 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SymbolicOCP__min__3 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
symbolicOCP_min__3 :: SymbolicOCPClass a => a -> String -> Bool -> IO Double
symbolicOCP_min__3 x = casadi__SymbolicOCP__min__3 (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "casadi__SymbolicOCP__nominal__0" c_casadi__SymbolicOCP__nominal__0
  :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr SX' -> IO (Ptr (StdVec CDouble))
casadi__SymbolicOCP__nominal__0
  :: SymbolicOCP -> SX -> IO (Vector Double)
casadi__SymbolicOCP__nominal__0 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SymbolicOCP__nominal__0 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
symbolicOCP_nominal__0 :: SymbolicOCPClass a => a -> SX -> IO (Vector Double)
symbolicOCP_nominal__0 x = casadi__SymbolicOCP__nominal__0 (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "casadi__SymbolicOCP__nominal__1" c_casadi__SymbolicOCP__nominal__1
  :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr StdString -> IO CDouble
casadi__SymbolicOCP__nominal__1
  :: SymbolicOCP -> String -> IO Double
casadi__SymbolicOCP__nominal__1 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SymbolicOCP__nominal__1 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
symbolicOCP_nominal__1 :: SymbolicOCPClass a => a -> String -> IO Double
symbolicOCP_nominal__1 x = casadi__SymbolicOCP__nominal__1 (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "casadi__SymbolicOCP__operator_call" c_casadi__SymbolicOCP__operator_call
  :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr StdString -> IO (Ptr SX')
casadi__SymbolicOCP__operator_call
  :: SymbolicOCP -> String -> IO SX
casadi__SymbolicOCP__operator_call x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SymbolicOCP__operator_call errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
symbolicOCP_operator_call :: SymbolicOCPClass a => a -> String -> IO SX
symbolicOCP_operator_call x = casadi__SymbolicOCP__operator_call (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "casadi__SymbolicOCP__parseFMI" c_casadi__SymbolicOCP__parseFMI
  :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr StdString -> IO ()
casadi__SymbolicOCP__parseFMI
  :: SymbolicOCP -> String -> IO ()
casadi__SymbolicOCP__parseFMI x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SymbolicOCP__parseFMI errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
symbolicOCP_parseFMI :: SymbolicOCPClass a => a -> String -> IO ()
symbolicOCP_parseFMI x = casadi__SymbolicOCP__parseFMI (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "casadi__SymbolicOCP__sanityCheck" c_casadi__SymbolicOCP__sanityCheck
  :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> IO ()
casadi__SymbolicOCP__sanityCheck
  :: SymbolicOCP -> IO ()
casadi__SymbolicOCP__sanityCheck x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SymbolicOCP__sanityCheck errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
symbolicOCP_sanityCheck :: SymbolicOCPClass a => a -> IO ()
symbolicOCP_sanityCheck x = casadi__SymbolicOCP__sanityCheck (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "casadi__SymbolicOCP__scaleEquations" c_casadi__SymbolicOCP__scaleEquations
  :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> IO ()
casadi__SymbolicOCP__scaleEquations
  :: SymbolicOCP -> IO ()
casadi__SymbolicOCP__scaleEquations x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SymbolicOCP__scaleEquations errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
symbolicOCP_scaleEquations :: SymbolicOCPClass a => a -> IO ()
symbolicOCP_scaleEquations x = casadi__SymbolicOCP__scaleEquations (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "casadi__SymbolicOCP__scaleVariables" c_casadi__SymbolicOCP__scaleVariables
  :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> IO ()
casadi__SymbolicOCP__scaleVariables
  :: SymbolicOCP -> IO ()
casadi__SymbolicOCP__scaleVariables x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SymbolicOCP__scaleVariables errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
symbolicOCP_scaleVariables :: SymbolicOCPClass a => a -> IO ()
symbolicOCP_scaleVariables x = casadi__SymbolicOCP__scaleVariables (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "casadi__SymbolicOCP__setDerivativeStart__0" c_casadi__SymbolicOCP__setDerivativeStart__0
  :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr SX' -> Ptr (StdVec CDouble) -> IO ()
casadi__SymbolicOCP__setDerivativeStart__0
  :: SymbolicOCP -> SX -> Vector Double -> IO ()
casadi__SymbolicOCP__setDerivativeStart__0 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SymbolicOCP__setDerivativeStart__0 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
symbolicOCP_setDerivativeStart__0 :: SymbolicOCPClass a => a -> SX -> Vector Double -> IO ()
symbolicOCP_setDerivativeStart__0 x = casadi__SymbolicOCP__setDerivativeStart__0 (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "casadi__SymbolicOCP__setDerivativeStart__1" c_casadi__SymbolicOCP__setDerivativeStart__1
  :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr SX' -> Ptr (StdVec CDouble) -> CInt -> IO ()
casadi__SymbolicOCP__setDerivativeStart__1
  :: SymbolicOCP -> SX -> Vector Double -> Bool -> IO ()
casadi__SymbolicOCP__setDerivativeStart__1 x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SymbolicOCP__setDerivativeStart__1 errStrPtrP x0' x1' x2' x3'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
symbolicOCP_setDerivativeStart__1 :: SymbolicOCPClass a => a -> SX -> Vector Double -> Bool -> IO ()
symbolicOCP_setDerivativeStart__1 x = casadi__SymbolicOCP__setDerivativeStart__1 (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "casadi__SymbolicOCP__setDerivativeStart__2" c_casadi__SymbolicOCP__setDerivativeStart__2
  :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr StdString -> CDouble -> IO ()
casadi__SymbolicOCP__setDerivativeStart__2
  :: SymbolicOCP -> String -> Double -> IO ()
casadi__SymbolicOCP__setDerivativeStart__2 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SymbolicOCP__setDerivativeStart__2 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
symbolicOCP_setDerivativeStart__2 :: SymbolicOCPClass a => a -> String -> Double -> IO ()
symbolicOCP_setDerivativeStart__2 x = casadi__SymbolicOCP__setDerivativeStart__2 (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "casadi__SymbolicOCP__setDerivativeStart__3" c_casadi__SymbolicOCP__setDerivativeStart__3
  :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr StdString -> CDouble -> CInt -> IO ()
casadi__SymbolicOCP__setDerivativeStart__3
  :: SymbolicOCP -> String -> Double -> Bool -> IO ()
casadi__SymbolicOCP__setDerivativeStart__3 x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SymbolicOCP__setDerivativeStart__3 errStrPtrP x0' x1' x2' x3'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
symbolicOCP_setDerivativeStart__3 :: SymbolicOCPClass a => a -> String -> Double -> Bool -> IO ()
symbolicOCP_setDerivativeStart__3 x = casadi__SymbolicOCP__setDerivativeStart__3 (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "casadi__SymbolicOCP__setInitialGuess__0" c_casadi__SymbolicOCP__setInitialGuess__0
  :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr SX' -> Ptr (StdVec CDouble) -> IO ()
casadi__SymbolicOCP__setInitialGuess__0
  :: SymbolicOCP -> SX -> Vector Double -> IO ()
casadi__SymbolicOCP__setInitialGuess__0 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SymbolicOCP__setInitialGuess__0 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
symbolicOCP_setInitialGuess__0 :: SymbolicOCPClass a => a -> SX -> Vector Double -> IO ()
symbolicOCP_setInitialGuess__0 x = casadi__SymbolicOCP__setInitialGuess__0 (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "casadi__SymbolicOCP__setInitialGuess__1" c_casadi__SymbolicOCP__setInitialGuess__1
  :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr SX' -> Ptr (StdVec CDouble) -> CInt -> IO ()
casadi__SymbolicOCP__setInitialGuess__1
  :: SymbolicOCP -> SX -> Vector Double -> Bool -> IO ()
casadi__SymbolicOCP__setInitialGuess__1 x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SymbolicOCP__setInitialGuess__1 errStrPtrP x0' x1' x2' x3'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
symbolicOCP_setInitialGuess__1 :: SymbolicOCPClass a => a -> SX -> Vector Double -> Bool -> IO ()
symbolicOCP_setInitialGuess__1 x = casadi__SymbolicOCP__setInitialGuess__1 (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "casadi__SymbolicOCP__setInitialGuess__2" c_casadi__SymbolicOCP__setInitialGuess__2
  :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr StdString -> CDouble -> IO ()
casadi__SymbolicOCP__setInitialGuess__2
  :: SymbolicOCP -> String -> Double -> IO ()
casadi__SymbolicOCP__setInitialGuess__2 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SymbolicOCP__setInitialGuess__2 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
symbolicOCP_setInitialGuess__2 :: SymbolicOCPClass a => a -> String -> Double -> IO ()
symbolicOCP_setInitialGuess__2 x = casadi__SymbolicOCP__setInitialGuess__2 (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "casadi__SymbolicOCP__setInitialGuess__3" c_casadi__SymbolicOCP__setInitialGuess__3
  :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr StdString -> CDouble -> CInt -> IO ()
casadi__SymbolicOCP__setInitialGuess__3
  :: SymbolicOCP -> String -> Double -> Bool -> IO ()
casadi__SymbolicOCP__setInitialGuess__3 x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SymbolicOCP__setInitialGuess__3 errStrPtrP x0' x1' x2' x3'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
symbolicOCP_setInitialGuess__3 :: SymbolicOCPClass a => a -> String -> Double -> Bool -> IO ()
symbolicOCP_setInitialGuess__3 x = casadi__SymbolicOCP__setInitialGuess__3 (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "casadi__SymbolicOCP__setMax__0" c_casadi__SymbolicOCP__setMax__0
  :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr SX' -> Ptr (StdVec CDouble) -> IO ()
casadi__SymbolicOCP__setMax__0
  :: SymbolicOCP -> SX -> Vector Double -> IO ()
casadi__SymbolicOCP__setMax__0 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SymbolicOCP__setMax__0 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
symbolicOCP_setMax__0 :: SymbolicOCPClass a => a -> SX -> Vector Double -> IO ()
symbolicOCP_setMax__0 x = casadi__SymbolicOCP__setMax__0 (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "casadi__SymbolicOCP__setMax__1" c_casadi__SymbolicOCP__setMax__1
  :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr SX' -> Ptr (StdVec CDouble) -> CInt -> IO ()
casadi__SymbolicOCP__setMax__1
  :: SymbolicOCP -> SX -> Vector Double -> Bool -> IO ()
casadi__SymbolicOCP__setMax__1 x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SymbolicOCP__setMax__1 errStrPtrP x0' x1' x2' x3'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
symbolicOCP_setMax__1 :: SymbolicOCPClass a => a -> SX -> Vector Double -> Bool -> IO ()
symbolicOCP_setMax__1 x = casadi__SymbolicOCP__setMax__1 (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "casadi__SymbolicOCP__setMax__2" c_casadi__SymbolicOCP__setMax__2
  :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr StdString -> CDouble -> IO ()
casadi__SymbolicOCP__setMax__2
  :: SymbolicOCP -> String -> Double -> IO ()
casadi__SymbolicOCP__setMax__2 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SymbolicOCP__setMax__2 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
symbolicOCP_setMax__2 :: SymbolicOCPClass a => a -> String -> Double -> IO ()
symbolicOCP_setMax__2 x = casadi__SymbolicOCP__setMax__2 (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "casadi__SymbolicOCP__setMax__3" c_casadi__SymbolicOCP__setMax__3
  :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr StdString -> CDouble -> CInt -> IO ()
casadi__SymbolicOCP__setMax__3
  :: SymbolicOCP -> String -> Double -> Bool -> IO ()
casadi__SymbolicOCP__setMax__3 x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SymbolicOCP__setMax__3 errStrPtrP x0' x1' x2' x3'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
symbolicOCP_setMax__3 :: SymbolicOCPClass a => a -> String -> Double -> Bool -> IO ()
symbolicOCP_setMax__3 x = casadi__SymbolicOCP__setMax__3 (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "casadi__SymbolicOCP__setMin__0" c_casadi__SymbolicOCP__setMin__0
  :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr SX' -> Ptr (StdVec CDouble) -> IO ()
casadi__SymbolicOCP__setMin__0
  :: SymbolicOCP -> SX -> Vector Double -> IO ()
casadi__SymbolicOCP__setMin__0 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SymbolicOCP__setMin__0 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
symbolicOCP_setMin__0 :: SymbolicOCPClass a => a -> SX -> Vector Double -> IO ()
symbolicOCP_setMin__0 x = casadi__SymbolicOCP__setMin__0 (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "casadi__SymbolicOCP__setMin__1" c_casadi__SymbolicOCP__setMin__1
  :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr SX' -> Ptr (StdVec CDouble) -> CInt -> IO ()
casadi__SymbolicOCP__setMin__1
  :: SymbolicOCP -> SX -> Vector Double -> Bool -> IO ()
casadi__SymbolicOCP__setMin__1 x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SymbolicOCP__setMin__1 errStrPtrP x0' x1' x2' x3'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
symbolicOCP_setMin__1 :: SymbolicOCPClass a => a -> SX -> Vector Double -> Bool -> IO ()
symbolicOCP_setMin__1 x = casadi__SymbolicOCP__setMin__1 (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "casadi__SymbolicOCP__setMin__2" c_casadi__SymbolicOCP__setMin__2
  :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr StdString -> CDouble -> IO ()
casadi__SymbolicOCP__setMin__2
  :: SymbolicOCP -> String -> Double -> IO ()
casadi__SymbolicOCP__setMin__2 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SymbolicOCP__setMin__2 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
symbolicOCP_setMin__2 :: SymbolicOCPClass a => a -> String -> Double -> IO ()
symbolicOCP_setMin__2 x = casadi__SymbolicOCP__setMin__2 (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "casadi__SymbolicOCP__setMin__3" c_casadi__SymbolicOCP__setMin__3
  :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr StdString -> CDouble -> CInt -> IO ()
casadi__SymbolicOCP__setMin__3
  :: SymbolicOCP -> String -> Double -> Bool -> IO ()
casadi__SymbolicOCP__setMin__3 x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SymbolicOCP__setMin__3 errStrPtrP x0' x1' x2' x3'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
symbolicOCP_setMin__3 :: SymbolicOCPClass a => a -> String -> Double -> Bool -> IO ()
symbolicOCP_setMin__3 x = casadi__SymbolicOCP__setMin__3 (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "casadi__SymbolicOCP__setNominal__0" c_casadi__SymbolicOCP__setNominal__0
  :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr SX' -> Ptr (StdVec CDouble) -> IO ()
casadi__SymbolicOCP__setNominal__0
  :: SymbolicOCP -> SX -> Vector Double -> IO ()
casadi__SymbolicOCP__setNominal__0 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SymbolicOCP__setNominal__0 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
symbolicOCP_setNominal__0 :: SymbolicOCPClass a => a -> SX -> Vector Double -> IO ()
symbolicOCP_setNominal__0 x = casadi__SymbolicOCP__setNominal__0 (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "casadi__SymbolicOCP__setNominal__1" c_casadi__SymbolicOCP__setNominal__1
  :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr StdString -> CDouble -> IO ()
casadi__SymbolicOCP__setNominal__1
  :: SymbolicOCP -> String -> Double -> IO ()
casadi__SymbolicOCP__setNominal__1 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SymbolicOCP__setNominal__1 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
symbolicOCP_setNominal__1 :: SymbolicOCPClass a => a -> String -> Double -> IO ()
symbolicOCP_setNominal__1 x = casadi__SymbolicOCP__setNominal__1 (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "casadi__SymbolicOCP__setStart__0" c_casadi__SymbolicOCP__setStart__0
  :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr SX' -> Ptr (StdVec CDouble) -> IO ()
casadi__SymbolicOCP__setStart__0
  :: SymbolicOCP -> SX -> Vector Double -> IO ()
casadi__SymbolicOCP__setStart__0 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SymbolicOCP__setStart__0 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
symbolicOCP_setStart__0 :: SymbolicOCPClass a => a -> SX -> Vector Double -> IO ()
symbolicOCP_setStart__0 x = casadi__SymbolicOCP__setStart__0 (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "casadi__SymbolicOCP__setStart__1" c_casadi__SymbolicOCP__setStart__1
  :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr SX' -> Ptr (StdVec CDouble) -> CInt -> IO ()
casadi__SymbolicOCP__setStart__1
  :: SymbolicOCP -> SX -> Vector Double -> Bool -> IO ()
casadi__SymbolicOCP__setStart__1 x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SymbolicOCP__setStart__1 errStrPtrP x0' x1' x2' x3'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
symbolicOCP_setStart__1 :: SymbolicOCPClass a => a -> SX -> Vector Double -> Bool -> IO ()
symbolicOCP_setStart__1 x = casadi__SymbolicOCP__setStart__1 (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "casadi__SymbolicOCP__setStart__2" c_casadi__SymbolicOCP__setStart__2
  :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr StdString -> CDouble -> IO ()
casadi__SymbolicOCP__setStart__2
  :: SymbolicOCP -> String -> Double -> IO ()
casadi__SymbolicOCP__setStart__2 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SymbolicOCP__setStart__2 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
symbolicOCP_setStart__2 :: SymbolicOCPClass a => a -> String -> Double -> IO ()
symbolicOCP_setStart__2 x = casadi__SymbolicOCP__setStart__2 (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "casadi__SymbolicOCP__setStart__3" c_casadi__SymbolicOCP__setStart__3
  :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr StdString -> CDouble -> CInt -> IO ()
casadi__SymbolicOCP__setStart__3
  :: SymbolicOCP -> String -> Double -> Bool -> IO ()
casadi__SymbolicOCP__setStart__3 x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SymbolicOCP__setStart__3 errStrPtrP x0' x1' x2' x3'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
symbolicOCP_setStart__3 :: SymbolicOCPClass a => a -> String -> Double -> Bool -> IO ()
symbolicOCP_setStart__3 x = casadi__SymbolicOCP__setStart__3 (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "casadi__SymbolicOCP__setUnit" c_casadi__SymbolicOCP__setUnit
  :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr StdString -> Ptr StdString -> IO ()
casadi__SymbolicOCP__setUnit
  :: SymbolicOCP -> String -> String -> IO ()
casadi__SymbolicOCP__setUnit x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SymbolicOCP__setUnit errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
symbolicOCP_setUnit :: SymbolicOCPClass a => a -> String -> String -> IO ()
symbolicOCP_setUnit x = casadi__SymbolicOCP__setUnit (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "casadi__SymbolicOCP__sort_alg" c_casadi__SymbolicOCP__sort_alg
  :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> IO ()
casadi__SymbolicOCP__sort_alg
  :: SymbolicOCP -> IO ()
casadi__SymbolicOCP__sort_alg x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SymbolicOCP__sort_alg errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
symbolicOCP_sort_alg :: SymbolicOCPClass a => a -> IO ()
symbolicOCP_sort_alg x = casadi__SymbolicOCP__sort_alg (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "casadi__SymbolicOCP__sort_dae" c_casadi__SymbolicOCP__sort_dae
  :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> IO ()
casadi__SymbolicOCP__sort_dae
  :: SymbolicOCP -> IO ()
casadi__SymbolicOCP__sort_dae x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SymbolicOCP__sort_dae errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
symbolicOCP_sort_dae :: SymbolicOCPClass a => a -> IO ()
symbolicOCP_sort_dae x = casadi__SymbolicOCP__sort_dae (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "casadi__SymbolicOCP__sort_i" c_casadi__SymbolicOCP__sort_i
  :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> IO ()
casadi__SymbolicOCP__sort_i
  :: SymbolicOCP -> IO ()
casadi__SymbolicOCP__sort_i x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SymbolicOCP__sort_i errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
symbolicOCP_sort_i :: SymbolicOCPClass a => a -> IO ()
symbolicOCP_sort_i x = casadi__SymbolicOCP__sort_i (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "casadi__SymbolicOCP__split_dae" c_casadi__SymbolicOCP__split_dae
  :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> IO ()
casadi__SymbolicOCP__split_dae
  :: SymbolicOCP -> IO ()
casadi__SymbolicOCP__split_dae x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SymbolicOCP__split_dae errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
symbolicOCP_split_dae :: SymbolicOCPClass a => a -> IO ()
symbolicOCP_split_dae x = casadi__SymbolicOCP__split_dae (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "casadi__SymbolicOCP__split_i" c_casadi__SymbolicOCP__split_i
  :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> IO ()
casadi__SymbolicOCP__split_i
  :: SymbolicOCP -> IO ()
casadi__SymbolicOCP__split_i x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SymbolicOCP__split_i errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
symbolicOCP_split_i :: SymbolicOCPClass a => a -> IO ()
symbolicOCP_split_i x = casadi__SymbolicOCP__split_i (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "casadi__SymbolicOCP__start__0" c_casadi__SymbolicOCP__start__0
  :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr SX' -> IO (Ptr (StdVec CDouble))
casadi__SymbolicOCP__start__0
  :: SymbolicOCP -> SX -> IO (Vector Double)
casadi__SymbolicOCP__start__0 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SymbolicOCP__start__0 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
symbolicOCP_start__0 :: SymbolicOCPClass a => a -> SX -> IO (Vector Double)
symbolicOCP_start__0 x = casadi__SymbolicOCP__start__0 (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "casadi__SymbolicOCP__start__1" c_casadi__SymbolicOCP__start__1
  :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr SX' -> CInt -> IO (Ptr (StdVec CDouble))
casadi__SymbolicOCP__start__1
  :: SymbolicOCP -> SX -> Bool -> IO (Vector Double)
casadi__SymbolicOCP__start__1 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SymbolicOCP__start__1 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
symbolicOCP_start__1 :: SymbolicOCPClass a => a -> SX -> Bool -> IO (Vector Double)
symbolicOCP_start__1 x = casadi__SymbolicOCP__start__1 (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "casadi__SymbolicOCP__start__2" c_casadi__SymbolicOCP__start__2
  :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr StdString -> IO CDouble
casadi__SymbolicOCP__start__2
  :: SymbolicOCP -> String -> IO Double
casadi__SymbolicOCP__start__2 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SymbolicOCP__start__2 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
symbolicOCP_start__2 :: SymbolicOCPClass a => a -> String -> IO Double
symbolicOCP_start__2 x = casadi__SymbolicOCP__start__2 (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "casadi__SymbolicOCP__start__3" c_casadi__SymbolicOCP__start__3
  :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr StdString -> CInt -> IO CDouble
casadi__SymbolicOCP__start__3
  :: SymbolicOCP -> String -> Bool -> IO Double
casadi__SymbolicOCP__start__3 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SymbolicOCP__start__3 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
symbolicOCP_start__3 :: SymbolicOCPClass a => a -> String -> Bool -> IO Double
symbolicOCP_start__3 x = casadi__SymbolicOCP__start__3 (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "casadi__SymbolicOCP__unit__0" c_casadi__SymbolicOCP__unit__0
  :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr SX' -> IO (Ptr StdString)
casadi__SymbolicOCP__unit__0
  :: SymbolicOCP -> SX -> IO String
casadi__SymbolicOCP__unit__0 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SymbolicOCP__unit__0 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
symbolicOCP_unit__0 :: SymbolicOCPClass a => a -> SX -> IO String
symbolicOCP_unit__0 x = casadi__SymbolicOCP__unit__0 (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "casadi__SymbolicOCP__unit__1" c_casadi__SymbolicOCP__unit__1
  :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr StdString -> IO (Ptr StdString)
casadi__SymbolicOCP__unit__1
  :: SymbolicOCP -> String -> IO String
casadi__SymbolicOCP__unit__1 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SymbolicOCP__unit__1 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
symbolicOCP_unit__1 :: SymbolicOCPClass a => a -> String -> IO String
symbolicOCP_unit__1 x = casadi__SymbolicOCP__unit__1 (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "casadi__SymbolicOCP__variable__0" c_casadi__SymbolicOCP__variable__0
  :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr StdString -> IO (Ptr Variable')
casadi__SymbolicOCP__variable__0
  :: SymbolicOCP -> String -> IO Variable
casadi__SymbolicOCP__variable__0 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SymbolicOCP__variable__0 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
symbolicOCP_variable__0 :: SymbolicOCPClass a => a -> String -> IO Variable
symbolicOCP_variable__0 x = casadi__SymbolicOCP__variable__0 (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "casadi__SymbolicOCP__variable__1" c_casadi__SymbolicOCP__variable__1
  :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr StdString -> IO (Ptr Variable')
casadi__SymbolicOCP__variable__1
  :: SymbolicOCP -> String -> IO Variable
casadi__SymbolicOCP__variable__1 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SymbolicOCP__variable__1 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
symbolicOCP_variable__1 :: SymbolicOCPClass a => a -> String -> IO Variable
symbolicOCP_variable__1 x = casadi__SymbolicOCP__variable__1 (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "casadi__SymbolicOCP__getRepresentation" c_casadi__SymbolicOCP__getRepresentation
  :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> IO (Ptr StdString)
casadi__SymbolicOCP__getRepresentation
  :: SymbolicOCP -> IO String
casadi__SymbolicOCP__getRepresentation x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SymbolicOCP__getRepresentation errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
symbolicOCP_getRepresentation :: SymbolicOCPClass a => a -> IO String
symbolicOCP_getRepresentation x = casadi__SymbolicOCP__getRepresentation (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "casadi__SymbolicOCP__getDescription" c_casadi__SymbolicOCP__getDescription
  :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> IO (Ptr StdString)
casadi__SymbolicOCP__getDescription
  :: SymbolicOCP -> IO String
casadi__SymbolicOCP__getDescription x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SymbolicOCP__getDescription errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
symbolicOCP_getDescription :: SymbolicOCPClass a => a -> IO String
symbolicOCP_getDescription x = casadi__SymbolicOCP__getDescription (castSymbolicOCP x)