SymbolicOCP.hs

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

module Casadi.Wrappers.Classes.SymbolicOCP
       (
         SymbolicOCP,
         SymbolicOCPClass(..),
         symbolicOCP,
         symbolicOCP',
         symbolicOCP_addVariable,
         symbolicOCP_atTime,
         symbolicOCP_atTime',
         symbolicOCP_atTime'',
         symbolicOCP_atTime''',
         symbolicOCP_beq,
         symbolicOCP_beq',
         symbolicOCP_der,
         symbolicOCP_der',
         symbolicOCP_derivativeStart,
         symbolicOCP_derivativeStart',
         symbolicOCP_derivativeStart'',
         symbolicOCP_derivativeStart''',
         symbolicOCP_eliminateAlgebraic,
         symbolicOCP_eliminateDependentParameterInterdependencies,
         symbolicOCP_eliminateDependentParameters,
         symbolicOCP_eliminateIndependentParameters,
         symbolicOCP_eliminateLagrangeTerms,
         symbolicOCP_eliminateOutputInterdependencies,
         symbolicOCP_eliminateOutputs,
         symbolicOCP_eliminateQuadratureStates,
         symbolicOCP_generateMuscodDatFile,
         symbolicOCP_initialGuess,
         symbolicOCP_initialGuess',
         symbolicOCP_makeExplicit,
         symbolicOCP_makeSemiExplicit,
         symbolicOCP_max,
         symbolicOCP_max',
         symbolicOCP_min,
         symbolicOCP_min',
         symbolicOCP_nominal,
         symbolicOCP_nominal',
         symbolicOCP_ode,
         symbolicOCP_ode',
         symbolicOCP_operator_call,
         symbolicOCP_parseFMI,
         symbolicOCP_scaleEquations,
         symbolicOCP_scaleVariables,
         symbolicOCP_separateAlgebraic,
         symbolicOCP_setBeq,
         symbolicOCP_setBeq',
         symbolicOCP_setDerivativeStart,
         symbolicOCP_setDerivativeStart',
         symbolicOCP_setDerivativeStart'',
         symbolicOCP_setDerivativeStart''',
         symbolicOCP_setInitialGuess,
         symbolicOCP_setInitialGuess',
         symbolicOCP_setMax,
         symbolicOCP_setMax',
         symbolicOCP_setMin,
         symbolicOCP_setMin',
         symbolicOCP_setNominal,
         symbolicOCP_setNominal',
         symbolicOCP_setOde,
         symbolicOCP_setOde',
         symbolicOCP_setStart,
         symbolicOCP_setStart',
         symbolicOCP_setStart'',
         symbolicOCP_setStart''',
         symbolicOCP_setUnit,
         symbolicOCP_sortALG,
         symbolicOCP_sortDAE,
         symbolicOCP_sortDependentParameters,
         symbolicOCP_sortOutputs,
         symbolicOCP_start,
         symbolicOCP_start',
         symbolicOCP_start'',
         symbolicOCP_start''',
         symbolicOCP_unit,
         symbolicOCP_unit',
         symbolicOCP_variable,
       ) where


import Prelude hiding ( Functor )

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

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

instance Show SymbolicOCP where
  show = unsafePerformIO . printableObject_getDescription
-- direct wrapper
foreign import ccall unsafe "CasADi__SymbolicOCP__parseFMI" c_CasADi__SymbolicOCP__parseFMI
  :: Ptr SymbolicOCP' -> Ptr StdString' -> IO ()
casADi__SymbolicOCP__parseFMI
  :: SymbolicOCP -> String -> IO ()
casADi__SymbolicOCP__parseFMI x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__SymbolicOCP__parseFMI x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>Parse from XML to C++ format.
-}
symbolicOCP_parseFMI :: SymbolicOCPClass a => a -> String -> IO ()
symbolicOCP_parseFMI x = casADi__SymbolicOCP__parseFMI (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SymbolicOCP__addVariable" c_CasADi__SymbolicOCP__addVariable
  :: Ptr SymbolicOCP' -> Ptr StdString' -> Ptr Variable' -> IO ()
casADi__SymbolicOCP__addVariable
  :: SymbolicOCP -> String -> Variable -> IO ()
casADi__SymbolicOCP__addVariable x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__SymbolicOCP__addVariable x0' x1' x2' >>= wrapReturn

-- classy wrapper
{-|
>Add a variable.
-}
symbolicOCP_addVariable :: SymbolicOCPClass a => a -> String -> Variable -> IO ()
symbolicOCP_addVariable x = casADi__SymbolicOCP__addVariable (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SymbolicOCP__variable" c_CasADi__SymbolicOCP__variable
  :: Ptr SymbolicOCP' -> Ptr StdString' -> IO (Ptr Variable')
casADi__SymbolicOCP__variable
  :: SymbolicOCP -> String -> IO Variable
casADi__SymbolicOCP__variable x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__SymbolicOCP__variable x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>Access a variable by name.
-}
symbolicOCP_variable :: SymbolicOCPClass a => a -> String -> IO Variable
symbolicOCP_variable x = casADi__SymbolicOCP__variable (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SymbolicOCP__separateAlgebraic" c_CasADi__SymbolicOCP__separateAlgebraic
  :: Ptr SymbolicOCP' -> IO ()
casADi__SymbolicOCP__separateAlgebraic
  :: SymbolicOCP -> IO ()
casADi__SymbolicOCP__separateAlgebraic x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SymbolicOCP__separateAlgebraic x0' >>= wrapReturn

-- classy wrapper
{-|
>Identify and separate the algebraic variables and equations in the DAE.
-}
symbolicOCP_separateAlgebraic :: SymbolicOCPClass a => a -> IO ()
symbolicOCP_separateAlgebraic x = casADi__SymbolicOCP__separateAlgebraic (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SymbolicOCP__eliminateAlgebraic" c_CasADi__SymbolicOCP__eliminateAlgebraic
  :: Ptr SymbolicOCP' -> IO ()
casADi__SymbolicOCP__eliminateAlgebraic
  :: SymbolicOCP -> IO ()
casADi__SymbolicOCP__eliminateAlgebraic x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SymbolicOCP__eliminateAlgebraic x0' >>= wrapReturn

-- classy wrapper
{-|
>Eliminate algebraic variables, transforming them into outputs.
-}
symbolicOCP_eliminateAlgebraic :: SymbolicOCPClass a => a -> IO ()
symbolicOCP_eliminateAlgebraic x = casADi__SymbolicOCP__eliminateAlgebraic (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SymbolicOCP__makeSemiExplicit" c_CasADi__SymbolicOCP__makeSemiExplicit
  :: Ptr SymbolicOCP' -> IO ()
casADi__SymbolicOCP__makeSemiExplicit
  :: SymbolicOCP -> IO ()
casADi__SymbolicOCP__makeSemiExplicit x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SymbolicOCP__makeSemiExplicit x0' >>= wrapReturn

-- classy wrapper
{-|
>Transform the implicit DAE to a semi-explicit DAE.
-}
symbolicOCP_makeSemiExplicit :: SymbolicOCPClass a => a -> IO ()
symbolicOCP_makeSemiExplicit x = casADi__SymbolicOCP__makeSemiExplicit (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SymbolicOCP__makeExplicit" c_CasADi__SymbolicOCP__makeExplicit
  :: Ptr SymbolicOCP' -> IO ()
casADi__SymbolicOCP__makeExplicit
  :: SymbolicOCP -> IO ()
casADi__SymbolicOCP__makeExplicit x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SymbolicOCP__makeExplicit x0' >>= wrapReturn

-- classy wrapper
{-|
>Transform the implicit DAE or semi-explicit DAE into an explicit ODE.
-}
symbolicOCP_makeExplicit :: SymbolicOCPClass a => a -> IO ()
symbolicOCP_makeExplicit x = casADi__SymbolicOCP__makeExplicit (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SymbolicOCP__eliminateIndependentParameters" c_CasADi__SymbolicOCP__eliminateIndependentParameters
  :: Ptr SymbolicOCP' -> IO ()
casADi__SymbolicOCP__eliminateIndependentParameters
  :: SymbolicOCP -> IO ()
casADi__SymbolicOCP__eliminateIndependentParameters x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SymbolicOCP__eliminateIndependentParameters x0' >>= wrapReturn

-- classy wrapper
{-|
>Eliminate independent parameters.
-}
symbolicOCP_eliminateIndependentParameters :: SymbolicOCPClass a => a -> IO ()
symbolicOCP_eliminateIndependentParameters x = casADi__SymbolicOCP__eliminateIndependentParameters (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SymbolicOCP__sortDependentParameters" c_CasADi__SymbolicOCP__sortDependentParameters
  :: Ptr SymbolicOCP' -> IO ()
casADi__SymbolicOCP__sortDependentParameters
  :: SymbolicOCP -> IO ()
casADi__SymbolicOCP__sortDependentParameters x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SymbolicOCP__sortDependentParameters x0' >>= wrapReturn

-- classy wrapper
{-|
>Sort the dependent parameters.
-}
symbolicOCP_sortDependentParameters :: SymbolicOCPClass a => a -> IO ()
symbolicOCP_sortDependentParameters x = casADi__SymbolicOCP__sortDependentParameters (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SymbolicOCP__eliminateDependentParameterInterdependencies" c_CasADi__SymbolicOCP__eliminateDependentParameterInterdependencies
  :: Ptr SymbolicOCP' -> IO ()
casADi__SymbolicOCP__eliminateDependentParameterInterdependencies
  :: SymbolicOCP -> IO ()
casADi__SymbolicOCP__eliminateDependentParameterInterdependencies x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SymbolicOCP__eliminateDependentParameterInterdependencies x0' >>= wrapReturn

-- classy wrapper
{-|
>Eliminate interdependencies amongst the dependent parameters.
-}
symbolicOCP_eliminateDependentParameterInterdependencies :: SymbolicOCPClass a => a -> IO ()
symbolicOCP_eliminateDependentParameterInterdependencies x = casADi__SymbolicOCP__eliminateDependentParameterInterdependencies (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SymbolicOCP__eliminateDependentParameters" c_CasADi__SymbolicOCP__eliminateDependentParameters
  :: Ptr SymbolicOCP' -> IO ()
casADi__SymbolicOCP__eliminateDependentParameters
  :: SymbolicOCP -> IO ()
casADi__SymbolicOCP__eliminateDependentParameters x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SymbolicOCP__eliminateDependentParameters x0' >>= wrapReturn

-- classy wrapper
{-|
>Eliminate dependent parameters.
-}
symbolicOCP_eliminateDependentParameters :: SymbolicOCPClass a => a -> IO ()
symbolicOCP_eliminateDependentParameters x = casADi__SymbolicOCP__eliminateDependentParameters (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SymbolicOCP__sortOutputs" c_CasADi__SymbolicOCP__sortOutputs
  :: Ptr SymbolicOCP' -> IO ()
casADi__SymbolicOCP__sortOutputs
  :: SymbolicOCP -> IO ()
casADi__SymbolicOCP__sortOutputs x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SymbolicOCP__sortOutputs x0' >>= wrapReturn

-- classy wrapper
{-|
>Sort the outputs.
-}
symbolicOCP_sortOutputs :: SymbolicOCPClass a => a -> IO ()
symbolicOCP_sortOutputs x = casADi__SymbolicOCP__sortOutputs (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SymbolicOCP__eliminateOutputInterdependencies" c_CasADi__SymbolicOCP__eliminateOutputInterdependencies
  :: Ptr SymbolicOCP' -> IO ()
casADi__SymbolicOCP__eliminateOutputInterdependencies
  :: SymbolicOCP -> IO ()
casADi__SymbolicOCP__eliminateOutputInterdependencies x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SymbolicOCP__eliminateOutputInterdependencies x0' >>= wrapReturn

-- classy wrapper
{-|
>Eliminate interdependencies amongst the outputs.
-}
symbolicOCP_eliminateOutputInterdependencies :: SymbolicOCPClass a => a -> IO ()
symbolicOCP_eliminateOutputInterdependencies x = casADi__SymbolicOCP__eliminateOutputInterdependencies (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SymbolicOCP__eliminateOutputs" c_CasADi__SymbolicOCP__eliminateOutputs
  :: Ptr SymbolicOCP' -> IO ()
casADi__SymbolicOCP__eliminateOutputs
  :: SymbolicOCP -> IO ()
casADi__SymbolicOCP__eliminateOutputs x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SymbolicOCP__eliminateOutputs x0' >>= wrapReturn

-- classy wrapper
{-|
>Eliminate outputs.
-}
symbolicOCP_eliminateOutputs :: SymbolicOCPClass a => a -> IO ()
symbolicOCP_eliminateOutputs x = casADi__SymbolicOCP__eliminateOutputs (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SymbolicOCP__eliminateLagrangeTerms" c_CasADi__SymbolicOCP__eliminateLagrangeTerms
  :: Ptr SymbolicOCP' -> IO ()
casADi__SymbolicOCP__eliminateLagrangeTerms
  :: SymbolicOCP -> IO ()
casADi__SymbolicOCP__eliminateLagrangeTerms x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SymbolicOCP__eliminateLagrangeTerms x0' >>= wrapReturn

-- classy wrapper
{-|
>Eliminate Lagrange terms from the objective function and make them
>quadrature states.
-}
symbolicOCP_eliminateLagrangeTerms :: SymbolicOCPClass a => a -> IO ()
symbolicOCP_eliminateLagrangeTerms x = casADi__SymbolicOCP__eliminateLagrangeTerms (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SymbolicOCP__eliminateQuadratureStates" c_CasADi__SymbolicOCP__eliminateQuadratureStates
  :: Ptr SymbolicOCP' -> IO ()
casADi__SymbolicOCP__eliminateQuadratureStates
  :: SymbolicOCP -> IO ()
casADi__SymbolicOCP__eliminateQuadratureStates x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SymbolicOCP__eliminateQuadratureStates x0' >>= wrapReturn

-- classy wrapper
{-|
>Eliminate quadrature states and turn them into ODE states.
-}
symbolicOCP_eliminateQuadratureStates :: SymbolicOCPClass a => a -> IO ()
symbolicOCP_eliminateQuadratureStates x = casADi__SymbolicOCP__eliminateQuadratureStates (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SymbolicOCP__sortDAE" c_CasADi__SymbolicOCP__sortDAE
  :: Ptr SymbolicOCP' -> IO ()
casADi__SymbolicOCP__sortDAE
  :: SymbolicOCP -> IO ()
casADi__SymbolicOCP__sortDAE x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SymbolicOCP__sortDAE x0' >>= wrapReturn

-- classy wrapper
{-|
>Sort the DAE and implictly defined states.
-}
symbolicOCP_sortDAE :: SymbolicOCPClass a => a -> IO ()
symbolicOCP_sortDAE x = casADi__SymbolicOCP__sortDAE (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SymbolicOCP__sortALG" c_CasADi__SymbolicOCP__sortALG
  :: Ptr SymbolicOCP' -> IO ()
casADi__SymbolicOCP__sortALG
  :: SymbolicOCP -> IO ()
casADi__SymbolicOCP__sortALG x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SymbolicOCP__sortALG x0' >>= wrapReturn

-- classy wrapper
{-|
>Sort the algebraic equations and algebraic states.
-}
symbolicOCP_sortALG :: SymbolicOCPClass a => a -> IO ()
symbolicOCP_sortALG x = casADi__SymbolicOCP__sortALG (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SymbolicOCP__generateMuscodDatFile" c_CasADi__SymbolicOCP__generateMuscodDatFile
  :: Ptr SymbolicOCP' -> Ptr StdString' -> IO ()
casADi__SymbolicOCP__generateMuscodDatFile
  :: SymbolicOCP -> String -> IO ()
casADi__SymbolicOCP__generateMuscodDatFile x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__SymbolicOCP__generateMuscodDatFile x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>Generate a MUSCOD-II compatible DAT file.
-}
symbolicOCP_generateMuscodDatFile :: SymbolicOCPClass a => a -> String -> IO ()
symbolicOCP_generateMuscodDatFile x = casADi__SymbolicOCP__generateMuscodDatFile (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SymbolicOCP__scaleVariables" c_CasADi__SymbolicOCP__scaleVariables
  :: Ptr SymbolicOCP' -> IO ()
casADi__SymbolicOCP__scaleVariables
  :: SymbolicOCP -> IO ()
casADi__SymbolicOCP__scaleVariables x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SymbolicOCP__scaleVariables x0' >>= wrapReturn

-- classy wrapper
{-|
>Scale the variables.
-}
symbolicOCP_scaleVariables :: SymbolicOCPClass a => a -> IO ()
symbolicOCP_scaleVariables x = casADi__SymbolicOCP__scaleVariables (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SymbolicOCP__scaleEquations" c_CasADi__SymbolicOCP__scaleEquations
  :: Ptr SymbolicOCP' -> IO ()
casADi__SymbolicOCP__scaleEquations
  :: SymbolicOCP -> IO ()
casADi__SymbolicOCP__scaleEquations x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SymbolicOCP__scaleEquations x0' >>= wrapReturn

-- classy wrapper
{-|
>Scale the implicit equations.
-}
symbolicOCP_scaleEquations :: SymbolicOCPClass a => a -> IO ()
symbolicOCP_scaleEquations x = casADi__SymbolicOCP__scaleEquations (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SymbolicOCP__operator_call" c_CasADi__SymbolicOCP__operator_call
  :: 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' ->
  c_CasADi__SymbolicOCP__operator_call x0' x1' >>= wrapReturn

-- 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__der" c_CasADi__SymbolicOCP__der
  :: Ptr SymbolicOCP' -> Ptr StdString' -> IO (Ptr SX')
casADi__SymbolicOCP__der
  :: SymbolicOCP -> String -> IO SX
casADi__SymbolicOCP__der x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__SymbolicOCP__der x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>>  SX CasADi::SymbolicOCP::der(const std::string &name) const 
>------------------------------------------------------------------------
>
>Get a derivative expression by name.
>
>>  SX CasADi::SymbolicOCP::der(const SX &var) const 
>------------------------------------------------------------------------
>
>Get a derivative expression by non-differentiated expression.
-}
symbolicOCP_der :: SymbolicOCPClass a => a -> String -> IO SX
symbolicOCP_der x = casADi__SymbolicOCP__der (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SymbolicOCP__der_TIC" c_CasADi__SymbolicOCP__der_TIC
  :: Ptr SymbolicOCP' -> Ptr SX' -> IO (Ptr SX')
casADi__SymbolicOCP__der'
  :: SymbolicOCP -> SX -> IO SX
casADi__SymbolicOCP__der' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__SymbolicOCP__der_TIC x0' x1' >>= wrapReturn

-- classy wrapper
symbolicOCP_der' :: SymbolicOCPClass a => a -> SX -> IO SX
symbolicOCP_der' x = casADi__SymbolicOCP__der' (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SymbolicOCP__beq" c_CasADi__SymbolicOCP__beq
  :: Ptr SymbolicOCP' -> Ptr StdString' -> IO (Ptr SX')
casADi__SymbolicOCP__beq
  :: SymbolicOCP -> String -> IO SX
casADi__SymbolicOCP__beq x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__SymbolicOCP__beq x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>>  SX CasADi::SymbolicOCP::beq(const std::string &name) const 
>------------------------------------------------------------------------
>
>Get a binding equation by name.
>
>>  SX CasADi::SymbolicOCP::beq(const SX &var) const 
>------------------------------------------------------------------------
>
>Get a binding equation by non-differentiated expression.
-}
symbolicOCP_beq :: SymbolicOCPClass a => a -> String -> IO SX
symbolicOCP_beq x = casADi__SymbolicOCP__beq (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SymbolicOCP__beq_TIC" c_CasADi__SymbolicOCP__beq_TIC
  :: Ptr SymbolicOCP' -> Ptr SX' -> IO (Ptr SX')
casADi__SymbolicOCP__beq'
  :: SymbolicOCP -> SX -> IO SX
casADi__SymbolicOCP__beq' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__SymbolicOCP__beq_TIC x0' x1' >>= wrapReturn

-- classy wrapper
symbolicOCP_beq' :: SymbolicOCPClass a => a -> SX -> IO SX
symbolicOCP_beq' x = casADi__SymbolicOCP__beq' (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SymbolicOCP__setBeq" c_CasADi__SymbolicOCP__setBeq
  :: Ptr SymbolicOCP' -> Ptr StdString' -> Ptr SX' -> IO ()
casADi__SymbolicOCP__setBeq
  :: SymbolicOCP -> String -> SX -> IO ()
casADi__SymbolicOCP__setBeq x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__SymbolicOCP__setBeq x0' x1' x2' >>= wrapReturn

-- classy wrapper
{-|
>>  void CasADi::SymbolicOCP::setBeq(const std::string &name, const SX &val)
>------------------------------------------------------------------------
>
>Set a binding equation by name.
>
>>  void CasADi::SymbolicOCP::setBeq(const SX &var, const SX &val)
>------------------------------------------------------------------------
>
>Set an binding expression by non-differentiated expression.
-}
symbolicOCP_setBeq :: SymbolicOCPClass a => a -> String -> SX -> IO ()
symbolicOCP_setBeq x = casADi__SymbolicOCP__setBeq (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SymbolicOCP__setBeq_TIC" c_CasADi__SymbolicOCP__setBeq_TIC
  :: Ptr SymbolicOCP' -> Ptr SX' -> Ptr SX' -> IO ()
casADi__SymbolicOCP__setBeq'
  :: SymbolicOCP -> SX -> SX -> IO ()
casADi__SymbolicOCP__setBeq' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__SymbolicOCP__setBeq_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
symbolicOCP_setBeq' :: SymbolicOCPClass a => a -> SX -> SX -> IO ()
symbolicOCP_setBeq' x = casADi__SymbolicOCP__setBeq' (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SymbolicOCP__ode" c_CasADi__SymbolicOCP__ode
  :: Ptr SymbolicOCP' -> Ptr StdString' -> IO (Ptr SX')
casADi__SymbolicOCP__ode
  :: SymbolicOCP -> String -> IO SX
casADi__SymbolicOCP__ode x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__SymbolicOCP__ode x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>>  SX CasADi::SymbolicOCP::ode(const std::string &name) const 
>------------------------------------------------------------------------
>
>Get a derivative binding equation (i.e. ordinary differential equation, ODE)
>by name. Returns variable expression if unknwon.
>
>>  SX CasADi::SymbolicOCP::ode(const SX &var) const 
>------------------------------------------------------------------------
>
>Get a derivative binding expression (i.e. ordinary differential equation,
>ODE) by non-differentiated expression. Returns derivative expression if
>unknown.
-}
symbolicOCP_ode :: SymbolicOCPClass a => a -> String -> IO SX
symbolicOCP_ode x = casADi__SymbolicOCP__ode (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SymbolicOCP__ode_TIC" c_CasADi__SymbolicOCP__ode_TIC
  :: Ptr SymbolicOCP' -> Ptr SX' -> IO (Ptr SX')
casADi__SymbolicOCP__ode'
  :: SymbolicOCP -> SX -> IO SX
casADi__SymbolicOCP__ode' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__SymbolicOCP__ode_TIC x0' x1' >>= wrapReturn

-- classy wrapper
symbolicOCP_ode' :: SymbolicOCPClass a => a -> SX -> IO SX
symbolicOCP_ode' x = casADi__SymbolicOCP__ode' (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SymbolicOCP__setOde" c_CasADi__SymbolicOCP__setOde
  :: Ptr SymbolicOCP' -> Ptr StdString' -> Ptr SX' -> IO ()
casADi__SymbolicOCP__setOde
  :: SymbolicOCP -> String -> SX -> IO ()
casADi__SymbolicOCP__setOde x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__SymbolicOCP__setOde x0' x1' x2' >>= wrapReturn

-- classy wrapper
{-|
>>  void CasADi::SymbolicOCP::setOde(const std::string &name, const SX &val)
>------------------------------------------------------------------------
>
>Set a derivative binding equation by name.
>
>>  void CasADi::SymbolicOCP::setOde(const SX &var, const SX &val)
>------------------------------------------------------------------------
>
>Set an derivative binding expression by non-differentiated expression.
-}
symbolicOCP_setOde :: SymbolicOCPClass a => a -> String -> SX -> IO ()
symbolicOCP_setOde x = casADi__SymbolicOCP__setOde (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SymbolicOCP__setOde_TIC" c_CasADi__SymbolicOCP__setOde_TIC
  :: Ptr SymbolicOCP' -> Ptr SX' -> Ptr SX' -> IO ()
casADi__SymbolicOCP__setOde'
  :: SymbolicOCP -> SX -> SX -> IO ()
casADi__SymbolicOCP__setOde' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__SymbolicOCP__setOde_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
symbolicOCP_setOde' :: SymbolicOCPClass a => a -> SX -> SX -> IO ()
symbolicOCP_setOde' x = casADi__SymbolicOCP__setOde' (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SymbolicOCP__nominal" c_CasADi__SymbolicOCP__nominal
  :: Ptr SymbolicOCP' -> Ptr StdString' -> IO CDouble
casADi__SymbolicOCP__nominal
  :: SymbolicOCP -> String -> IO Double
casADi__SymbolicOCP__nominal x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__SymbolicOCP__nominal x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>>  double CasADi::SymbolicOCP::nominal(const std::string &name) const 
>------------------------------------------------------------------------
>
>Get the nominal value by name.
>
>>  std::vector< double > CasADi::SymbolicOCP::nominal(const SX &var) const 
>------------------------------------------------------------------------
>
>Get the nominal value(s) by expression.
-}
symbolicOCP_nominal :: SymbolicOCPClass a => a -> String -> IO Double
symbolicOCP_nominal x = casADi__SymbolicOCP__nominal (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SymbolicOCP__nominal_TIC" c_CasADi__SymbolicOCP__nominal_TIC
  :: Ptr SymbolicOCP' -> Ptr SX' -> IO (Ptr (CppVec CDouble))
casADi__SymbolicOCP__nominal'
  :: SymbolicOCP -> SX -> IO (Vector Double)
casADi__SymbolicOCP__nominal' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__SymbolicOCP__nominal_TIC x0' x1' >>= wrapReturn

-- classy wrapper
symbolicOCP_nominal' :: SymbolicOCPClass a => a -> SX -> IO (Vector Double)
symbolicOCP_nominal' x = casADi__SymbolicOCP__nominal' (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SymbolicOCP__setNominal" c_CasADi__SymbolicOCP__setNominal
  :: Ptr SymbolicOCP' -> Ptr StdString' -> CDouble -> IO ()
casADi__SymbolicOCP__setNominal
  :: SymbolicOCP -> String -> Double -> IO ()
casADi__SymbolicOCP__setNominal x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__SymbolicOCP__setNominal x0' x1' x2' >>= wrapReturn

-- classy wrapper
{-|
>>  void CasADi::SymbolicOCP::setNominal(const std::string &name, double val)
>------------------------------------------------------------------------
>
>Set the nominal value by name.
>
>>  void CasADi::SymbolicOCP::setNominal(const SX &var, const std::vector< double > &val)
>------------------------------------------------------------------------
>
>Set the nominal value(s) by expression.
-}
symbolicOCP_setNominal :: SymbolicOCPClass a => a -> String -> Double -> IO ()
symbolicOCP_setNominal x = casADi__SymbolicOCP__setNominal (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SymbolicOCP__setNominal_TIC" c_CasADi__SymbolicOCP__setNominal_TIC
  :: Ptr SymbolicOCP' -> Ptr SX' -> Ptr (CppVec CDouble) -> IO ()
casADi__SymbolicOCP__setNominal'
  :: SymbolicOCP -> SX -> Vector Double -> IO ()
casADi__SymbolicOCP__setNominal' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__SymbolicOCP__setNominal_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
symbolicOCP_setNominal' :: SymbolicOCPClass a => a -> SX -> Vector Double -> IO ()
symbolicOCP_setNominal' x = casADi__SymbolicOCP__setNominal' (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SymbolicOCP__min" c_CasADi__SymbolicOCP__min
  :: Ptr SymbolicOCP' -> Ptr StdString' -> IO (Ptr SX')
casADi__SymbolicOCP__min
  :: SymbolicOCP -> String -> IO SX
casADi__SymbolicOCP__min x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__SymbolicOCP__min x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>>  SX CasADi::SymbolicOCP::min(const std::string &name) const 
>------------------------------------------------------------------------
>
>Get the lower bound by name.
>
>>  SX CasADi::SymbolicOCP::min(const SX &var) const 
>------------------------------------------------------------------------
>
>Get the lower bound(s) by expression.
-}
symbolicOCP_min :: SymbolicOCPClass a => a -> String -> IO SX
symbolicOCP_min x = casADi__SymbolicOCP__min (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SymbolicOCP__min_TIC" c_CasADi__SymbolicOCP__min_TIC
  :: Ptr SymbolicOCP' -> Ptr SX' -> IO (Ptr SX')
casADi__SymbolicOCP__min'
  :: SymbolicOCP -> SX -> IO SX
casADi__SymbolicOCP__min' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__SymbolicOCP__min_TIC x0' x1' >>= wrapReturn

-- classy wrapper
symbolicOCP_min' :: SymbolicOCPClass a => a -> SX -> IO SX
symbolicOCP_min' x = casADi__SymbolicOCP__min' (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SymbolicOCP__setMin" c_CasADi__SymbolicOCP__setMin
  :: Ptr SymbolicOCP' -> Ptr StdString' -> Ptr SX' -> IO ()
casADi__SymbolicOCP__setMin
  :: SymbolicOCP -> String -> SX -> IO ()
casADi__SymbolicOCP__setMin x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__SymbolicOCP__setMin x0' x1' x2' >>= wrapReturn

-- classy wrapper
{-|
>>  void CasADi::SymbolicOCP::setMin(const std::string &name, const SX &val)
>------------------------------------------------------------------------
>
>Set the lower bound by name.
>
>>  void CasADi::SymbolicOCP::setMin(const SX &var, const SX &val)
>------------------------------------------------------------------------
>
>Set the lower bound(s) by expression.
-}
symbolicOCP_setMin :: SymbolicOCPClass a => a -> String -> SX -> IO ()
symbolicOCP_setMin x = casADi__SymbolicOCP__setMin (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SymbolicOCP__setMin_TIC" c_CasADi__SymbolicOCP__setMin_TIC
  :: Ptr SymbolicOCP' -> Ptr SX' -> Ptr SX' -> IO ()
casADi__SymbolicOCP__setMin'
  :: SymbolicOCP -> SX -> SX -> IO ()
casADi__SymbolicOCP__setMin' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__SymbolicOCP__setMin_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
symbolicOCP_setMin' :: SymbolicOCPClass a => a -> SX -> SX -> IO ()
symbolicOCP_setMin' x = casADi__SymbolicOCP__setMin' (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SymbolicOCP__max" c_CasADi__SymbolicOCP__max
  :: Ptr SymbolicOCP' -> Ptr StdString' -> IO (Ptr SX')
casADi__SymbolicOCP__max
  :: SymbolicOCP -> String -> IO SX
casADi__SymbolicOCP__max x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__SymbolicOCP__max x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>>  SX CasADi::SymbolicOCP::max(const std::string &name) const 
>------------------------------------------------------------------------
>
>Get the upper bound by name.
>
>>  SX CasADi::SymbolicOCP::max(const SX &var) const 
>------------------------------------------------------------------------
>
>Get the upper bound(s) by expression.
-}
symbolicOCP_max :: SymbolicOCPClass a => a -> String -> IO SX
symbolicOCP_max x = casADi__SymbolicOCP__max (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SymbolicOCP__max_TIC" c_CasADi__SymbolicOCP__max_TIC
  :: Ptr SymbolicOCP' -> Ptr SX' -> IO (Ptr SX')
casADi__SymbolicOCP__max'
  :: SymbolicOCP -> SX -> IO SX
casADi__SymbolicOCP__max' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__SymbolicOCP__max_TIC x0' x1' >>= wrapReturn

-- classy wrapper
symbolicOCP_max' :: SymbolicOCPClass a => a -> SX -> IO SX
symbolicOCP_max' x = casADi__SymbolicOCP__max' (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SymbolicOCP__setMax" c_CasADi__SymbolicOCP__setMax
  :: Ptr SymbolicOCP' -> Ptr StdString' -> Ptr SX' -> IO ()
casADi__SymbolicOCP__setMax
  :: SymbolicOCP -> String -> SX -> IO ()
casADi__SymbolicOCP__setMax x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__SymbolicOCP__setMax x0' x1' x2' >>= wrapReturn

-- classy wrapper
{-|
>>  void CasADi::SymbolicOCP::setMax(const std::string &name, const SX &val)
>------------------------------------------------------------------------
>
>Set the upper bound by name.
>
>>  void CasADi::SymbolicOCP::setMax(const SX &var, const SX &val)
>------------------------------------------------------------------------
>
>Set the upper bound(s) by expression.
-}
symbolicOCP_setMax :: SymbolicOCPClass a => a -> String -> SX -> IO ()
symbolicOCP_setMax x = casADi__SymbolicOCP__setMax (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SymbolicOCP__setMax_TIC" c_CasADi__SymbolicOCP__setMax_TIC
  :: Ptr SymbolicOCP' -> Ptr SX' -> Ptr SX' -> IO ()
casADi__SymbolicOCP__setMax'
  :: SymbolicOCP -> SX -> SX -> IO ()
casADi__SymbolicOCP__setMax' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__SymbolicOCP__setMax_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
symbolicOCP_setMax' :: SymbolicOCPClass a => a -> SX -> SX -> IO ()
symbolicOCP_setMax' x = casADi__SymbolicOCP__setMax' (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SymbolicOCP__initialGuess" c_CasADi__SymbolicOCP__initialGuess
  :: Ptr SymbolicOCP' -> Ptr StdString' -> IO (Ptr SX')
casADi__SymbolicOCP__initialGuess
  :: SymbolicOCP -> String -> IO SX
casADi__SymbolicOCP__initialGuess x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__SymbolicOCP__initialGuess x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>>  SX CasADi::SymbolicOCP::initialGuess(const std::string &name) const 
>------------------------------------------------------------------------
>
>Get the initial guess by name.
>
>>  SX CasADi::SymbolicOCP::initialGuess(const SX &var) const 
>------------------------------------------------------------------------
>
>Get the initial guess(es) by expression.
-}
symbolicOCP_initialGuess :: SymbolicOCPClass a => a -> String -> IO SX
symbolicOCP_initialGuess x = casADi__SymbolicOCP__initialGuess (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SymbolicOCP__initialGuess_TIC" c_CasADi__SymbolicOCP__initialGuess_TIC
  :: Ptr SymbolicOCP' -> Ptr SX' -> IO (Ptr SX')
casADi__SymbolicOCP__initialGuess'
  :: SymbolicOCP -> SX -> IO SX
casADi__SymbolicOCP__initialGuess' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__SymbolicOCP__initialGuess_TIC x0' x1' >>= wrapReturn

-- classy wrapper
symbolicOCP_initialGuess' :: SymbolicOCPClass a => a -> SX -> IO SX
symbolicOCP_initialGuess' x = casADi__SymbolicOCP__initialGuess' (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SymbolicOCP__setInitialGuess" c_CasADi__SymbolicOCP__setInitialGuess
  :: Ptr SymbolicOCP' -> Ptr StdString' -> Ptr SX' -> IO ()
casADi__SymbolicOCP__setInitialGuess
  :: SymbolicOCP -> String -> SX -> IO ()
casADi__SymbolicOCP__setInitialGuess x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__SymbolicOCP__setInitialGuess x0' x1' x2' >>= wrapReturn

-- classy wrapper
{-|
>>  void CasADi::SymbolicOCP::setInitialGuess(const std::string &name, const SX &val)
>------------------------------------------------------------------------
>
>Set the initial guess by name.
>
>>  void CasADi::SymbolicOCP::setInitialGuess(const SX &var, const SX &val)
>------------------------------------------------------------------------
>
>Set the initial guess(es) by expression.
-}
symbolicOCP_setInitialGuess :: SymbolicOCPClass a => a -> String -> SX -> IO ()
symbolicOCP_setInitialGuess x = casADi__SymbolicOCP__setInitialGuess (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SymbolicOCP__setInitialGuess_TIC" c_CasADi__SymbolicOCP__setInitialGuess_TIC
  :: Ptr SymbolicOCP' -> Ptr SX' -> Ptr SX' -> IO ()
casADi__SymbolicOCP__setInitialGuess'
  :: SymbolicOCP -> SX -> SX -> IO ()
casADi__SymbolicOCP__setInitialGuess' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__SymbolicOCP__setInitialGuess_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
symbolicOCP_setInitialGuess' :: SymbolicOCPClass a => a -> SX -> SX -> IO ()
symbolicOCP_setInitialGuess' x = casADi__SymbolicOCP__setInitialGuess' (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SymbolicOCP__start" c_CasADi__SymbolicOCP__start
  :: Ptr SymbolicOCP' -> Ptr StdString' -> CInt -> IO CDouble
casADi__SymbolicOCP__start
  :: SymbolicOCP -> String -> Bool -> IO Double
casADi__SymbolicOCP__start x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__SymbolicOCP__start x0' x1' x2' >>= wrapReturn

-- classy wrapper
{-|
>>  double CasADi::SymbolicOCP::start(const std::string &name, bool normalized=false) const 
>------------------------------------------------------------------------
>
>Get the (optionally normalized) value at time 0 by name.
>
>>  std::vector< double > CasADi::SymbolicOCP::start(const SX &var, bool normalized=false) const 
>------------------------------------------------------------------------
>
>Get the (optionally normalized) value(s) at time 0 by expression.
-}
symbolicOCP_start :: SymbolicOCPClass a => a -> String -> Bool -> IO Double
symbolicOCP_start x = casADi__SymbolicOCP__start (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SymbolicOCP__start_TIC" c_CasADi__SymbolicOCP__start_TIC
  :: Ptr SymbolicOCP' -> Ptr StdString' -> IO CDouble
casADi__SymbolicOCP__start'
  :: SymbolicOCP -> String -> IO Double
casADi__SymbolicOCP__start' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__SymbolicOCP__start_TIC x0' x1' >>= wrapReturn

-- classy wrapper
symbolicOCP_start' :: SymbolicOCPClass a => a -> String -> IO Double
symbolicOCP_start' x = casADi__SymbolicOCP__start' (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SymbolicOCP__start_TIC_TIC" c_CasADi__SymbolicOCP__start_TIC_TIC
  :: Ptr SymbolicOCP' -> Ptr SX' -> CInt -> IO (Ptr (CppVec CDouble))
casADi__SymbolicOCP__start''
  :: SymbolicOCP -> SX -> Bool -> IO (Vector Double)
casADi__SymbolicOCP__start'' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__SymbolicOCP__start_TIC_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
symbolicOCP_start'' :: SymbolicOCPClass a => a -> SX -> Bool -> IO (Vector Double)
symbolicOCP_start'' x = casADi__SymbolicOCP__start'' (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SymbolicOCP__start_TIC_TIC_TIC" c_CasADi__SymbolicOCP__start_TIC_TIC_TIC
  :: Ptr SymbolicOCP' -> Ptr SX' -> IO (Ptr (CppVec CDouble))
casADi__SymbolicOCP__start'''
  :: SymbolicOCP -> SX -> IO (Vector Double)
casADi__SymbolicOCP__start''' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__SymbolicOCP__start_TIC_TIC_TIC x0' x1' >>= wrapReturn

-- classy wrapper
symbolicOCP_start''' :: SymbolicOCPClass a => a -> SX -> IO (Vector Double)
symbolicOCP_start''' x = casADi__SymbolicOCP__start''' (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SymbolicOCP__setStart" c_CasADi__SymbolicOCP__setStart
  :: Ptr SymbolicOCP' -> Ptr StdString' -> CDouble -> CInt -> IO ()
casADi__SymbolicOCP__setStart
  :: SymbolicOCP -> String -> Double -> Bool -> IO ()
casADi__SymbolicOCP__setStart x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  c_CasADi__SymbolicOCP__setStart x0' x1' x2' x3' >>= wrapReturn

-- classy wrapper
{-|
>>  void CasADi::SymbolicOCP::setStart(const std::string &name, double val, bool normalized=false)
>------------------------------------------------------------------------
>
>Set the (optionally normalized) value at time 0 by name.
>
>>  void CasADi::SymbolicOCP::setStart(const SX &var, const std::vector< double > &val, bool normalized=false)
>------------------------------------------------------------------------
>
>Set the (optionally normalized) value(s) at time 0 by expression.
-}
symbolicOCP_setStart :: SymbolicOCPClass a => a -> String -> Double -> Bool -> IO ()
symbolicOCP_setStart x = casADi__SymbolicOCP__setStart (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SymbolicOCP__setStart_TIC" c_CasADi__SymbolicOCP__setStart_TIC
  :: Ptr SymbolicOCP' -> Ptr StdString' -> CDouble -> IO ()
casADi__SymbolicOCP__setStart'
  :: SymbolicOCP -> String -> Double -> IO ()
casADi__SymbolicOCP__setStart' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__SymbolicOCP__setStart_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
symbolicOCP_setStart' :: SymbolicOCPClass a => a -> String -> Double -> IO ()
symbolicOCP_setStart' x = casADi__SymbolicOCP__setStart' (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SymbolicOCP__setStart_TIC_TIC" c_CasADi__SymbolicOCP__setStart_TIC_TIC
  :: Ptr SymbolicOCP' -> Ptr SX' -> Ptr (CppVec CDouble) -> CInt -> IO ()
casADi__SymbolicOCP__setStart''
  :: SymbolicOCP -> SX -> Vector Double -> Bool -> IO ()
casADi__SymbolicOCP__setStart'' x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  c_CasADi__SymbolicOCP__setStart_TIC_TIC x0' x1' x2' x3' >>= wrapReturn

-- classy wrapper
symbolicOCP_setStart'' :: SymbolicOCPClass a => a -> SX -> Vector Double -> Bool -> IO ()
symbolicOCP_setStart'' x = casADi__SymbolicOCP__setStart'' (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SymbolicOCP__setStart_TIC_TIC_TIC" c_CasADi__SymbolicOCP__setStart_TIC_TIC_TIC
  :: Ptr SymbolicOCP' -> Ptr SX' -> Ptr (CppVec CDouble) -> IO ()
casADi__SymbolicOCP__setStart'''
  :: SymbolicOCP -> SX -> Vector Double -> IO ()
casADi__SymbolicOCP__setStart''' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__SymbolicOCP__setStart_TIC_TIC_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
symbolicOCP_setStart''' :: SymbolicOCPClass a => a -> SX -> Vector Double -> IO ()
symbolicOCP_setStart''' x = casADi__SymbolicOCP__setStart''' (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SymbolicOCP__derivativeStart" c_CasADi__SymbolicOCP__derivativeStart
  :: Ptr SymbolicOCP' -> Ptr StdString' -> CInt -> IO CDouble
casADi__SymbolicOCP__derivativeStart
  :: SymbolicOCP -> String -> Bool -> IO Double
casADi__SymbolicOCP__derivativeStart x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__SymbolicOCP__derivativeStart x0' x1' x2' >>= wrapReturn

-- classy wrapper
{-|
>>  double CasADi::SymbolicOCP::derivativeStart(const std::string &name, bool normalized=false) const 
>------------------------------------------------------------------------
>
>Get the (optionally normalized) derivative value at time 0 by name.
>
>>  std::vector< double > CasADi::SymbolicOCP::derivativeStart(const SX &var, bool normalized=false) const 
>------------------------------------------------------------------------
>
>Get the (optionally normalized) derivative value(s) at time 0 by expression.
-}
symbolicOCP_derivativeStart :: SymbolicOCPClass a => a -> String -> Bool -> IO Double
symbolicOCP_derivativeStart x = casADi__SymbolicOCP__derivativeStart (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SymbolicOCP__derivativeStart_TIC" c_CasADi__SymbolicOCP__derivativeStart_TIC
  :: Ptr SymbolicOCP' -> Ptr StdString' -> IO CDouble
casADi__SymbolicOCP__derivativeStart'
  :: SymbolicOCP -> String -> IO Double
casADi__SymbolicOCP__derivativeStart' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__SymbolicOCP__derivativeStart_TIC x0' x1' >>= wrapReturn

-- classy wrapper
symbolicOCP_derivativeStart' :: SymbolicOCPClass a => a -> String -> IO Double
symbolicOCP_derivativeStart' x = casADi__SymbolicOCP__derivativeStart' (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SymbolicOCP__derivativeStart_TIC_TIC" c_CasADi__SymbolicOCP__derivativeStart_TIC_TIC
  :: Ptr SymbolicOCP' -> Ptr SX' -> CInt -> IO (Ptr (CppVec CDouble))
casADi__SymbolicOCP__derivativeStart''
  :: SymbolicOCP -> SX -> Bool -> IO (Vector Double)
casADi__SymbolicOCP__derivativeStart'' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__SymbolicOCP__derivativeStart_TIC_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
symbolicOCP_derivativeStart'' :: SymbolicOCPClass a => a -> SX -> Bool -> IO (Vector Double)
symbolicOCP_derivativeStart'' x = casADi__SymbolicOCP__derivativeStart'' (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SymbolicOCP__derivativeStart_TIC_TIC_TIC" c_CasADi__SymbolicOCP__derivativeStart_TIC_TIC_TIC
  :: Ptr SymbolicOCP' -> Ptr SX' -> IO (Ptr (CppVec CDouble))
casADi__SymbolicOCP__derivativeStart'''
  :: SymbolicOCP -> SX -> IO (Vector Double)
casADi__SymbolicOCP__derivativeStart''' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__SymbolicOCP__derivativeStart_TIC_TIC_TIC x0' x1' >>= wrapReturn

-- classy wrapper
symbolicOCP_derivativeStart''' :: SymbolicOCPClass a => a -> SX -> IO (Vector Double)
symbolicOCP_derivativeStart''' x = casADi__SymbolicOCP__derivativeStart''' (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SymbolicOCP__setDerivativeStart" c_CasADi__SymbolicOCP__setDerivativeStart
  :: Ptr SymbolicOCP' -> Ptr StdString' -> CDouble -> CInt -> IO ()
casADi__SymbolicOCP__setDerivativeStart
  :: SymbolicOCP -> String -> Double -> Bool -> IO ()
casADi__SymbolicOCP__setDerivativeStart x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  c_CasADi__SymbolicOCP__setDerivativeStart x0' x1' x2' x3' >>= wrapReturn

-- classy wrapper
{-|
>>  void CasADi::SymbolicOCP::setDerivativeStart(const std::string &name, double val, bool normalized=false)
>------------------------------------------------------------------------
>
>Set the (optionally normalized) derivative value at time 0 by name.
>
>>  void CasADi::SymbolicOCP::setDerivativeStart(const SX &var, const std::vector< double > &val, bool normalized=false)
>------------------------------------------------------------------------
>
>Set the (optionally normalized) derivative value(s) at time 0 by expression.
-}
symbolicOCP_setDerivativeStart :: SymbolicOCPClass a => a -> String -> Double -> Bool -> IO ()
symbolicOCP_setDerivativeStart x = casADi__SymbolicOCP__setDerivativeStart (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SymbolicOCP__setDerivativeStart_TIC" c_CasADi__SymbolicOCP__setDerivativeStart_TIC
  :: Ptr SymbolicOCP' -> Ptr StdString' -> CDouble -> IO ()
casADi__SymbolicOCP__setDerivativeStart'
  :: SymbolicOCP -> String -> Double -> IO ()
casADi__SymbolicOCP__setDerivativeStart' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__SymbolicOCP__setDerivativeStart_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
symbolicOCP_setDerivativeStart' :: SymbolicOCPClass a => a -> String -> Double -> IO ()
symbolicOCP_setDerivativeStart' x = casADi__SymbolicOCP__setDerivativeStart' (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SymbolicOCP__setDerivativeStart_TIC_TIC" c_CasADi__SymbolicOCP__setDerivativeStart_TIC_TIC
  :: Ptr SymbolicOCP' -> Ptr SX' -> Ptr (CppVec CDouble) -> CInt -> IO ()
casADi__SymbolicOCP__setDerivativeStart''
  :: SymbolicOCP -> SX -> Vector Double -> Bool -> IO ()
casADi__SymbolicOCP__setDerivativeStart'' x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  c_CasADi__SymbolicOCP__setDerivativeStart_TIC_TIC x0' x1' x2' x3' >>= wrapReturn

-- classy wrapper
symbolicOCP_setDerivativeStart'' :: SymbolicOCPClass a => a -> SX -> Vector Double -> Bool -> IO ()
symbolicOCP_setDerivativeStart'' x = casADi__SymbolicOCP__setDerivativeStart'' (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SymbolicOCP__setDerivativeStart_TIC_TIC_TIC" c_CasADi__SymbolicOCP__setDerivativeStart_TIC_TIC_TIC
  :: Ptr SymbolicOCP' -> Ptr SX' -> Ptr (CppVec CDouble) -> IO ()
casADi__SymbolicOCP__setDerivativeStart'''
  :: SymbolicOCP -> SX -> Vector Double -> IO ()
casADi__SymbolicOCP__setDerivativeStart''' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__SymbolicOCP__setDerivativeStart_TIC_TIC_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
symbolicOCP_setDerivativeStart''' :: SymbolicOCPClass a => a -> SX -> Vector Double -> IO ()
symbolicOCP_setDerivativeStart''' x = casADi__SymbolicOCP__setDerivativeStart''' (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SymbolicOCP__unit" c_CasADi__SymbolicOCP__unit
  :: Ptr SymbolicOCP' -> Ptr StdString' -> IO (Ptr StdString')
casADi__SymbolicOCP__unit
  :: SymbolicOCP -> String -> IO String
casADi__SymbolicOCP__unit x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__SymbolicOCP__unit x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>>  std::string CasADi::SymbolicOCP::unit(const std::string &name) const 
>------------------------------------------------------------------------
>
>Get the unit for a component.
>
>>  std::string CasADi::SymbolicOCP::unit(const SX &var) const 
>------------------------------------------------------------------------
>
>Get the unit given a vector of symbolic variables (all units must be
>identical)
-}
symbolicOCP_unit :: SymbolicOCPClass a => a -> String -> IO String
symbolicOCP_unit x = casADi__SymbolicOCP__unit (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SymbolicOCP__unit_TIC" c_CasADi__SymbolicOCP__unit_TIC
  :: Ptr SymbolicOCP' -> Ptr SX' -> IO (Ptr StdString')
casADi__SymbolicOCP__unit'
  :: SymbolicOCP -> SX -> IO String
casADi__SymbolicOCP__unit' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__SymbolicOCP__unit_TIC x0' x1' >>= wrapReturn

-- classy wrapper
symbolicOCP_unit' :: SymbolicOCPClass a => a -> SX -> IO String
symbolicOCP_unit' x = casADi__SymbolicOCP__unit' (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SymbolicOCP__setUnit" c_CasADi__SymbolicOCP__setUnit
  :: 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' ->
  c_CasADi__SymbolicOCP__setUnit x0' x1' x2' >>= wrapReturn

-- classy wrapper
{-|
>Set the unit for a component.
-}
symbolicOCP_setUnit :: SymbolicOCPClass a => a -> String -> String -> IO ()
symbolicOCP_setUnit x = casADi__SymbolicOCP__setUnit (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SymbolicOCP__atTime" c_CasADi__SymbolicOCP__atTime
  :: Ptr SymbolicOCP' -> Ptr StdString' -> CDouble -> CInt -> IO (Ptr SX')
casADi__SymbolicOCP__atTime
  :: SymbolicOCP -> String -> Double -> Bool -> IO SX
casADi__SymbolicOCP__atTime x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  c_CasADi__SymbolicOCP__atTime x0' x1' x2' x3' >>= wrapReturn

-- classy wrapper
{-|
>>  SX CasADi::SymbolicOCP::atTime(const std::string &name, double t, bool allocate=false) const 
>------------------------------------------------------------------------
>
>Timed variable (never allocate)
>
>>  SX CasADi::SymbolicOCP::atTime(const std::string &name, double t, bool allocate=false)
>------------------------------------------------------------------------
>
>Timed variable (allocate if necessary)
-}
symbolicOCP_atTime :: SymbolicOCPClass a => a -> String -> Double -> Bool -> IO SX
symbolicOCP_atTime x = casADi__SymbolicOCP__atTime (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SymbolicOCP__atTime_TIC" c_CasADi__SymbolicOCP__atTime_TIC
  :: Ptr SymbolicOCP' -> Ptr StdString' -> CDouble -> IO (Ptr SX')
casADi__SymbolicOCP__atTime'
  :: SymbolicOCP -> String -> Double -> IO SX
casADi__SymbolicOCP__atTime' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__SymbolicOCP__atTime_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
symbolicOCP_atTime' :: SymbolicOCPClass a => a -> String -> Double -> IO SX
symbolicOCP_atTime' x = casADi__SymbolicOCP__atTime' (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SymbolicOCP__atTime_TIC_TIC" c_CasADi__SymbolicOCP__atTime_TIC_TIC
  :: Ptr SymbolicOCP' -> Ptr StdString' -> CDouble -> CInt -> IO (Ptr SX')
casADi__SymbolicOCP__atTime''
  :: SymbolicOCP -> String -> Double -> Bool -> IO SX
casADi__SymbolicOCP__atTime'' x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  c_CasADi__SymbolicOCP__atTime_TIC_TIC x0' x1' x2' x3' >>= wrapReturn

-- classy wrapper
symbolicOCP_atTime'' :: SymbolicOCPClass a => a -> String -> Double -> Bool -> IO SX
symbolicOCP_atTime'' x = casADi__SymbolicOCP__atTime'' (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SymbolicOCP__atTime_TIC_TIC_TIC" c_CasADi__SymbolicOCP__atTime_TIC_TIC_TIC
  :: Ptr SymbolicOCP' -> Ptr StdString' -> CDouble -> IO (Ptr SX')
casADi__SymbolicOCP__atTime'''
  :: SymbolicOCP -> String -> Double -> IO SX
casADi__SymbolicOCP__atTime''' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__SymbolicOCP__atTime_TIC_TIC_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
symbolicOCP_atTime''' :: SymbolicOCPClass a => a -> String -> Double -> IO SX
symbolicOCP_atTime''' x = casADi__SymbolicOCP__atTime''' (castSymbolicOCP x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SymbolicOCP__SymbolicOCP" c_CasADi__SymbolicOCP__SymbolicOCP
  :: CInt -> IO (Ptr SymbolicOCP')
casADi__SymbolicOCP__SymbolicOCP
  :: Bool -> IO SymbolicOCP
casADi__SymbolicOCP__SymbolicOCP x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SymbolicOCP__SymbolicOCP x0' >>= wrapReturn

-- classy wrapper
{-|
>Default constructor.
-}
symbolicOCP :: Bool -> IO SymbolicOCP
symbolicOCP = casADi__SymbolicOCP__SymbolicOCP


-- direct wrapper
foreign import ccall unsafe "CasADi__SymbolicOCP__SymbolicOCP_TIC" c_CasADi__SymbolicOCP__SymbolicOCP_TIC
  :: IO (Ptr SymbolicOCP')
casADi__SymbolicOCP__SymbolicOCP'
  :: IO SymbolicOCP
casADi__SymbolicOCP__SymbolicOCP'  =
  c_CasADi__SymbolicOCP__SymbolicOCP_TIC  >>= wrapReturn

-- classy wrapper
symbolicOCP' :: IO SymbolicOCP
symbolicOCP' = casADi__SymbolicOCP__SymbolicOCP'