casadi-bindings-core-2.1.0.0: Casadi/Core/Classes/MX.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.MX
       (
         MX,
         MXClass(..),
         mx__0,
         mx__1,
         mx__2,
         mx__3,
         mx__4,
         mx__5,
         mx__6,
         mx__7,
         mx__8,
         mx___add__,
         mx___constpow__,
         mx___copysign__,
         mx___div__,
         mx___eq__,
         mx___ge__,
         mx___gt__,
         mx___hash__,
         mx___le__,
         mx___lt__,
         mx___mldivide__,
         mx___mpower__,
         mx___mrdivide__,
         mx___mul__,
         mx___ne__,
         mx___nonzero__,
         mx___pow__,
         mx___radd__,
         mx___rdiv__,
         mx___req__,
         mx___rge__,
         mx___rgt__,
         mx___rle__,
         mx___rlt__,
         mx___rmul__,
         mx___rne__,
         mx___rsub__,
         mx___rtruediv__,
         mx___sub__,
         mx___truediv____0,
         mx___truediv____1,
         mx_addToSum,
         mx_append,
         mx_appendColumns,
         mx_arccos,
         mx_arccosh,
         mx_arcsin,
         mx_arcsinh,
         mx_arctan,
         mx_arctan2,
         mx_arctanh,
         mx_attachAssert__0,
         mx_attachAssert__1,
         mx_binary,
         mx_ceil,
         mx_constpow,
         mx_cos,
         mx_cosh,
         mx_densify__0,
         mx_densify__1,
         mx_dimString,
         mx_enlarge,
         mx_erase,
         mx_erf,
         mx_erfinv,
         mx_exp,
         mx_eye,
         mx_fabs,
         mx_floor,
         mx_fmax,
         mx_fmin,
         mx_fmod,
         mx_getDep__0,
         mx_getDep__1,
         mx_getEqualityCheckingDepth,
         mx_getEvaluationOutput,
         mx_getFunction,
         mx_getMatrixValue,
         mx_getMaxNumCallsInPrint,
         mx_getNZ__0,
         mx_getNZ__1,
         mx_getNZ__2,
         mx_getNZ__3,
         mx_getName,
         mx_getNdeps,
         mx_getNumOutputs,
         mx_getOp,
         mx_getOutput__0,
         mx_getOutput__1,
         mx_getTemp,
         mx_getValue,
         mx_if_else_zero,
         mx_indexed__0,
         mx_indexed__1,
         mx_indexed__2,
         mx_indexed__3,
         mx_indexed__4,
         mx_indexed__5,
         mx_indexed__6,
         mx_indexed_assignment__0,
         mx_indexed_assignment__1,
         mx_indexed_assignment__2,
         mx_indexed_assignment__3,
         mx_indexed_assignment__4,
         mx_indexed_assignment__5,
         mx_indexed_one_based__0,
         mx_indexed_one_based__1,
         mx_indexed_one_based_assignment__0,
         mx_indexed_one_based_assignment__1,
         mx_indexed_zero_based__0,
         mx_indexed_zero_based__1,
         mx_indexed_zero_based_assignment__0,
         mx_indexed_zero_based_assignment__1,
         mx_indexed_zero_based_assignment__2,
         mx_inf__0,
         mx_inf__1,
         mx_inf__2,
         mx_inf__3,
         mx_inner_prod,
         mx_isBinary,
         mx_isCommutative,
         mx_isConstant,
         mx_isDense,
         mx_isEmpty__0,
         mx_isEmpty__1,
         mx_isEqual__0,
         mx_isEqual__1,
         mx_isEvaluation,
         mx_isEvaluationOutput,
         mx_isIdentity,
         mx_isMinusOne,
         mx_isMultiplication,
         mx_isNorm,
         mx_isOne,
         mx_isOperation,
         mx_isRegular,
         mx_isScalar__0,
         mx_isScalar__1,
         mx_isSquare,
         mx_isSymbolic,
         mx_isSymbolicSparse,
         mx_isTranspose,
         mx_isTril,
         mx_isTriu,
         mx_isUnary,
         mx_isVector,
         mx_isZero,
         mx_lift,
         mx_log,
         mx_log10,
         mx_logic_and,
         mx_logic_not,
         mx_logic_or,
         mx_mapping,
         mx_mul__0,
         mx_mul__1,
         mx_mul_full__0,
         mx_mul_full__1,
         mx_mul_smart,
         mx_nan__0,
         mx_nan__1,
         mx_nan__2,
         mx_nan__3,
         mx_numel,
         mx_nz_indexed__0,
         mx_nz_indexed__1,
         mx_nz_indexed_assignment__0,
         mx_nz_indexed_assignment__1,
         mx_nz_indexed_one_based,
         mx_nz_indexed_one_based_assignment,
         mx_nz_indexed_zero_based,
         mx_nz_indexed_zero_based_assignment,
         mx_ones__0,
         mx_ones__1,
         mx_ones__2,
         mx_ones__3,
         mx_outer_prod,
         mx_printme,
         mx_repmat__0,
         mx_repmat__1,
         mx_repmat__2,
         mx_setEqualityCheckingDepth__0,
         mx_setEqualityCheckingDepth__1,
         mx_setMaxNumCallsInPrint__0,
         mx_setMaxNumCallsInPrint__1,
         mx_setNZ__0,
         mx_setNZ__1,
         mx_setNZ__2,
         mx_setNZ__3,
         mx_setSparse__0,
         mx_setSparse__1,
         mx_setSub__0,
         mx_setSub__1,
         mx_setSub__10,
         mx_setSub__11,
         mx_setSub__2,
         mx_setSub__3,
         mx_setSub__4,
         mx_setSub__5,
         mx_setSub__6,
         mx_setSub__7,
         mx_setSub__8,
         mx_setSub__9,
         mx_setTemp,
         mx_sign,
         mx_sin,
         mx_sinh,
         mx_size1,
         mx_size2,
         mx_sizeD,
         mx_sizeL,
         mx_sizeU,
         mx_size__0,
         mx_size__1,
         mx_sparse__0,
         mx_sparse__1,
         mx_sparse__2,
         mx_sparsityRef__0,
         mx_sparsityRef__1,
         mx_sparsity__0,
         mx_sparsity__1,
         mx_sqrt,
         mx_sub__0,
         mx_sub__1,
         mx_sub__10,
         mx_sub__11,
         mx_sub__12,
         mx_sub__13,
         mx_sub__14,
         mx_sub__15,
         mx_sub__2,
         mx_sub__3,
         mx_sub__4,
         mx_sub__5,
         mx_sub__6,
         mx_sub__7,
         mx_sub__8,
         mx_sub__9,
         mx_sym__0,
         mx_sym__1,
         mx_sym__2,
         mx_sym__3,
         mx_sym__4,
         mx_sym__5,
         mx_sym__6,
         mx_sym__7,
         mx_tan,
         mx_tanh,
         mx_trans,
         mx_unary,
         mx_zeros__0,
         mx_zeros__1,
         mx_zeros__2,
         mx_zeros__3,
       ) 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__MX__CONSTRUCTOR__0" c_casadi__MX__CONSTRUCTOR__0
  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr MX')
casadi__MX__CONSTRUCTOR__0
  :: DMatrix -> IO MX
casadi__MX__CONSTRUCTOR__0 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__MX__CONSTRUCTOR__0 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
mx__0 :: DMatrix -> IO MX
mx__0 = casadi__MX__CONSTRUCTOR__0


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


-- classy wrapper
mx__1 :: Vector Double -> IO MX
mx__1 = casadi__MX__CONSTRUCTOR__1


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


-- classy wrapper
mx__2 :: MX -> IO MX
mx__2 = casadi__MX__CONSTRUCTOR__2


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


-- classy wrapper
mx__3 :: Double -> IO MX
mx__3 = casadi__MX__CONSTRUCTOR__3


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


-- classy wrapper
mx__4 :: Sparsity -> MX -> IO MX
mx__4 = casadi__MX__CONSTRUCTOR__4


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


-- classy wrapper
mx__5 :: Sparsity -> Double -> IO MX
mx__5 = casadi__MX__CONSTRUCTOR__5


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


-- classy wrapper
mx__6 :: Sparsity -> IO MX
mx__6 = casadi__MX__CONSTRUCTOR__6


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


-- classy wrapper
mx__7 :: Sparsity -> Int -> IO MX
mx__7 = casadi__MX__CONSTRUCTOR__7


-- direct wrapper
foreign import ccall unsafe "casadi__MX__CONSTRUCTOR__8" c_casadi__MX__CONSTRUCTOR__8
  :: Ptr (Ptr StdString) -> IO (Ptr MX')
casadi__MX__CONSTRUCTOR__8
  :: IO MX
casadi__MX__CONSTRUCTOR__8  =

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


-- classy wrapper
mx__8 :: IO MX
mx__8 = casadi__MX__CONSTRUCTOR__8


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


-- classy wrapper
mx___add__ :: MXClass a => a -> MX -> IO MX
mx___add__ x = casadi__MX____add__ (castMX x)


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


-- classy wrapper
mx___constpow__ :: MXClass a => a -> MX -> IO MX
mx___constpow__ x = casadi__MX____constpow__ (castMX x)


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


-- classy wrapper
mx___copysign__ :: MXClass a => a -> MX -> IO MX
mx___copysign__ x = casadi__MX____copysign__ (castMX x)


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


-- classy wrapper
mx___div__ :: MXClass a => a -> MX -> IO MX
mx___div__ x = casadi__MX____div__ (castMX x)


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


-- classy wrapper
mx___eq__ :: MXClass a => a -> MX -> IO MX
mx___eq__ x = casadi__MX____eq__ (castMX x)


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


-- classy wrapper
mx___ge__ :: MXClass a => a -> MX -> IO MX
mx___ge__ x = casadi__MX____ge__ (castMX x)


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


-- classy wrapper
mx___gt__ :: MXClass a => a -> MX -> IO MX
mx___gt__ x = casadi__MX____gt__ (castMX x)


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


-- classy wrapper
mx___hash__ :: MXClass a => a -> IO Int
mx___hash__ x = casadi__MX____hash__ (castMX x)


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


-- classy wrapper
mx___le__ :: MXClass a => a -> MX -> IO MX
mx___le__ x = casadi__MX____le__ (castMX x)


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


-- classy wrapper
mx___lt__ :: MXClass a => a -> MX -> IO MX
mx___lt__ x = casadi__MX____lt__ (castMX x)


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


-- classy wrapper
mx___mldivide__ :: MXClass a => a -> MX -> IO MX
mx___mldivide__ x = casadi__MX____mldivide__ (castMX x)


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


-- classy wrapper
mx___mpower__ :: MXClass a => a -> MX -> IO MX
mx___mpower__ x = casadi__MX____mpower__ (castMX x)


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


-- classy wrapper
mx___mrdivide__ :: MXClass a => a -> MX -> IO MX
mx___mrdivide__ x = casadi__MX____mrdivide__ (castMX x)


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


-- classy wrapper
mx___mul__ :: MXClass a => a -> MX -> IO MX
mx___mul__ x = casadi__MX____mul__ (castMX x)


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


-- classy wrapper
mx___ne__ :: MXClass a => a -> MX -> IO MX
mx___ne__ x = casadi__MX____ne__ (castMX x)


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


-- classy wrapper
mx___nonzero__ :: MXClass a => a -> IO Bool
mx___nonzero__ x = casadi__MX____nonzero__ (castMX x)


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


-- classy wrapper
mx___pow__ :: MXClass a => a -> MX -> IO MX
mx___pow__ x = casadi__MX____pow__ (castMX x)


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


-- classy wrapper
mx___radd__ :: MXClass a => a -> MX -> IO MX
mx___radd__ x = casadi__MX____radd__ (castMX x)


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


-- classy wrapper
mx___rdiv__ :: MXClass a => a -> MX -> IO MX
mx___rdiv__ x = casadi__MX____rdiv__ (castMX x)


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


-- classy wrapper
mx___req__ :: MXClass a => a -> MX -> IO MX
mx___req__ x = casadi__MX____req__ (castMX x)


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


-- classy wrapper
mx___rge__ :: MXClass a => a -> MX -> IO MX
mx___rge__ x = casadi__MX____rge__ (castMX x)


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


-- classy wrapper
mx___rgt__ :: MXClass a => a -> MX -> IO MX
mx___rgt__ x = casadi__MX____rgt__ (castMX x)


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


-- classy wrapper
mx___rle__ :: MXClass a => a -> MX -> IO MX
mx___rle__ x = casadi__MX____rle__ (castMX x)


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


-- classy wrapper
mx___rlt__ :: MXClass a => a -> MX -> IO MX
mx___rlt__ x = casadi__MX____rlt__ (castMX x)


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


-- classy wrapper
mx___rmul__ :: MXClass a => a -> MX -> IO MX
mx___rmul__ x = casadi__MX____rmul__ (castMX x)


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


-- classy wrapper
mx___rne__ :: MXClass a => a -> MX -> IO MX
mx___rne__ x = casadi__MX____rne__ (castMX x)


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


-- classy wrapper
mx___rsub__ :: MXClass a => a -> MX -> IO MX
mx___rsub__ x = casadi__MX____rsub__ (castMX x)


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


-- classy wrapper
mx___rtruediv__ :: MXClass a => a -> MX -> IO MX
mx___rtruediv__ x = casadi__MX____rtruediv__ (castMX x)


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


-- classy wrapper
mx___sub__ :: MXClass a => a -> MX -> IO MX
mx___sub__ x = casadi__MX____sub__ (castMX x)


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


-- classy wrapper
mx___truediv____0 :: MXClass a => a -> MX -> IO MX
mx___truediv____0 x = casadi__MX____truediv____0 (castMX x)


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


-- classy wrapper
mx___truediv____1 :: MXClass a => a -> MX -> IO MX
mx___truediv____1 x = casadi__MX____truediv____1 (castMX x)


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


-- classy wrapper
mx_addToSum :: MXClass a => a -> MX -> IO ()
mx_addToSum x = casadi__MX__addToSum (castMX x)


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


-- classy wrapper
mx_append :: MXClass a => a -> MX -> IO ()
mx_append x = casadi__MX__append (castMX x)


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


-- classy wrapper
mx_appendColumns :: MXClass a => a -> MX -> IO ()
mx_appendColumns x = casadi__MX__appendColumns (castMX x)


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


-- classy wrapper
mx_arccos :: MXClass a => a -> IO MX
mx_arccos x = casadi__MX__arccos (castMX x)


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


-- classy wrapper
mx_arccosh :: MXClass a => a -> IO MX
mx_arccosh x = casadi__MX__arccosh (castMX x)


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


-- classy wrapper
mx_arcsin :: MXClass a => a -> IO MX
mx_arcsin x = casadi__MX__arcsin (castMX x)


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


-- classy wrapper
mx_arcsinh :: MXClass a => a -> IO MX
mx_arcsinh x = casadi__MX__arcsinh (castMX x)


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


-- classy wrapper
mx_arctan :: MXClass a => a -> IO MX
mx_arctan x = casadi__MX__arctan (castMX x)


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


-- classy wrapper
mx_arctan2 :: MXClass a => a -> MX -> IO MX
mx_arctan2 x = casadi__MX__arctan2 (castMX x)


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


-- classy wrapper
mx_arctanh :: MXClass a => a -> IO MX
mx_arctanh x = casadi__MX__arctanh (castMX x)


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


-- classy wrapper
mx_attachAssert__0 :: MXClass a => a -> MX -> IO MX
mx_attachAssert__0 x = casadi__MX__attachAssert__0 (castMX x)


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


-- classy wrapper
mx_attachAssert__1 :: MXClass a => a -> MX -> String -> IO MX
mx_attachAssert__1 x = casadi__MX__attachAssert__1 (castMX x)


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


-- classy wrapper
mx_binary :: Int -> MX -> MX -> IO MX
mx_binary = casadi__MX__binary


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


-- classy wrapper
mx_ceil :: MXClass a => a -> IO MX
mx_ceil x = casadi__MX__ceil (castMX x)


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


-- classy wrapper
mx_constpow :: MXClass a => a -> MX -> IO MX
mx_constpow x = casadi__MX__constpow (castMX x)


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


-- classy wrapper
mx_cos :: MXClass a => a -> IO MX
mx_cos x = casadi__MX__cos (castMX x)


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


-- classy wrapper
mx_cosh :: MXClass a => a -> IO MX
mx_cosh x = casadi__MX__cosh (castMX x)


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


-- classy wrapper
mx_densify__0 :: MXClass a => a -> IO ()
mx_densify__0 x = casadi__MX__densify__0 (castMX x)


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


-- classy wrapper
mx_densify__1 :: MXClass a => a -> MX -> IO ()
mx_densify__1 x = casadi__MX__densify__1 (castMX x)


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


-- classy wrapper
mx_dimString :: MXClass a => a -> IO String
mx_dimString x = casadi__MX__dimString (castMX x)


-- direct wrapper
foreign import ccall unsafe "casadi__MX__enlarge" c_casadi__MX__enlarge
  :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> CInt -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO ()
casadi__MX__enlarge
  :: MX -> Int -> Int -> Vector Int -> Vector Int -> IO ()
casadi__MX__enlarge x0 x1 x2 x3 x4 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__MX__enlarge errStrPtrP x0' x1' x2' x3' x4'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
mx_enlarge :: MXClass a => a -> Int -> Int -> Vector Int -> Vector Int -> IO ()
mx_enlarge x = casadi__MX__enlarge (castMX x)


-- direct wrapper
foreign import ccall unsafe "casadi__MX__erase" c_casadi__MX__erase
  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO ()
casadi__MX__erase
  :: MX -> Vector Int -> Vector Int -> IO ()
casadi__MX__erase x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__MX__erase errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
mx_erase :: MXClass a => a -> Vector Int -> Vector Int -> IO ()
mx_erase x = casadi__MX__erase (castMX x)


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


-- classy wrapper
mx_erf :: MXClass a => a -> IO MX
mx_erf x = casadi__MX__erf (castMX x)


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


-- classy wrapper
mx_erfinv :: MXClass a => a -> IO MX
mx_erfinv x = casadi__MX__erfinv (castMX x)


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


-- classy wrapper
mx_exp :: MXClass a => a -> IO MX
mx_exp x = casadi__MX__exp (castMX x)


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


-- classy wrapper
mx_eye :: Int -> IO MX
mx_eye = casadi__MX__eye


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


-- classy wrapper
mx_fabs :: MXClass a => a -> IO MX
mx_fabs x = casadi__MX__fabs (castMX x)


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


-- classy wrapper
mx_floor :: MXClass a => a -> IO MX
mx_floor x = casadi__MX__floor (castMX x)


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


-- classy wrapper
mx_fmax :: MXClass a => a -> MX -> IO MX
mx_fmax x = casadi__MX__fmax (castMX x)


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


-- classy wrapper
mx_fmin :: MXClass a => a -> MX -> IO MX
mx_fmin x = casadi__MX__fmin (castMX x)


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


-- classy wrapper
mx_fmod :: MXClass a => a -> MX -> IO MX
mx_fmod x = casadi__MX__fmod (castMX x)


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


-- classy wrapper
mx_getDep__0 :: MXClass a => a -> IO MX
mx_getDep__0 x = casadi__MX__getDep__0 (castMX x)


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


-- classy wrapper
mx_getDep__1 :: MXClass a => a -> Int -> IO MX
mx_getDep__1 x = casadi__MX__getDep__1 (castMX x)


-- direct wrapper
foreign import ccall unsafe "casadi__MX__getEqualityCheckingDepth" c_casadi__MX__getEqualityCheckingDepth
  :: Ptr (Ptr StdString) -> IO CInt
casadi__MX__getEqualityCheckingDepth
  :: IO Int
casadi__MX__getEqualityCheckingDepth  =

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


-- classy wrapper
mx_getEqualityCheckingDepth :: IO Int
mx_getEqualityCheckingDepth = casadi__MX__getEqualityCheckingDepth


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


-- classy wrapper
mx_getEvaluationOutput :: MXClass a => a -> IO Int
mx_getEvaluationOutput x = casadi__MX__getEvaluationOutput (castMX x)


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


-- classy wrapper
mx_getFunction :: MXClass a => a -> IO Function
mx_getFunction x = casadi__MX__getFunction (castMX x)


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


-- classy wrapper
mx_getMatrixValue :: MXClass a => a -> IO DMatrix
mx_getMatrixValue x = casadi__MX__getMatrixValue (castMX x)


-- direct wrapper
foreign import ccall unsafe "casadi__MX__getMaxNumCallsInPrint" c_casadi__MX__getMaxNumCallsInPrint
  :: Ptr (Ptr StdString) -> IO CLong
casadi__MX__getMaxNumCallsInPrint
  :: IO Int
casadi__MX__getMaxNumCallsInPrint  =

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


-- classy wrapper
mx_getMaxNumCallsInPrint :: IO Int
mx_getMaxNumCallsInPrint = casadi__MX__getMaxNumCallsInPrint


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


-- classy wrapper
mx_getNZ__0 :: MXClass a => a -> IMatrix -> IO MX
mx_getNZ__0 x = casadi__MX__getNZ__0 (castMX x)


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


-- classy wrapper
mx_getNZ__1 :: MXClass a => a -> Slice -> IO MX
mx_getNZ__1 x = casadi__MX__getNZ__1 (castMX x)


-- direct wrapper
foreign import ccall unsafe "casadi__MX__getNZ__2" c_casadi__MX__getNZ__2
  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (StdVec CInt) -> IO (Ptr MX')
casadi__MX__getNZ__2
  :: MX -> Vector Int -> IO MX
casadi__MX__getNZ__2 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__MX__getNZ__2 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
mx_getNZ__2 :: MXClass a => a -> Vector Int -> IO MX
mx_getNZ__2 x = casadi__MX__getNZ__2 (castMX x)


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


-- classy wrapper
mx_getNZ__3 :: MXClass a => a -> Int -> IO MX
mx_getNZ__3 x = casadi__MX__getNZ__3 (castMX x)


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


-- classy wrapper
mx_getName :: MXClass a => a -> IO String
mx_getName x = casadi__MX__getName (castMX x)


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


-- classy wrapper
mx_getNdeps :: MXClass a => a -> IO Int
mx_getNdeps x = casadi__MX__getNdeps (castMX x)


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


-- classy wrapper
mx_getNumOutputs :: MXClass a => a -> IO Int
mx_getNumOutputs x = casadi__MX__getNumOutputs (castMX x)


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


-- classy wrapper
mx_getOp :: MXClass a => a -> IO Int
mx_getOp x = casadi__MX__getOp (castMX x)


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


-- classy wrapper
mx_getOutput__0 :: MXClass a => a -> IO MX
mx_getOutput__0 x = casadi__MX__getOutput__0 (castMX x)


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


-- classy wrapper
mx_getOutput__1 :: MXClass a => a -> Int -> IO MX
mx_getOutput__1 x = casadi__MX__getOutput__1 (castMX x)


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


-- classy wrapper
mx_getTemp :: MXClass a => a -> IO Int
mx_getTemp x = casadi__MX__getTemp (castMX x)


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


-- classy wrapper
mx_getValue :: MXClass a => a -> IO Double
mx_getValue x = casadi__MX__getValue (castMX x)


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


-- classy wrapper
mx_if_else_zero :: MXClass a => a -> MX -> IO MX
mx_if_else_zero x = casadi__MX__if_else_zero (castMX x)


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


-- classy wrapper
mx_indexed__0 :: MXClass a => a -> Slice -> IO MX
mx_indexed__0 x = casadi__MX__indexed__0 (castMX x)


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


-- classy wrapper
mx_indexed__1 :: MXClass a => a -> IMatrix -> IMatrix -> IO MX
mx_indexed__1 x = casadi__MX__indexed__1 (castMX x)


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


-- classy wrapper
mx_indexed__2 :: MXClass a => a -> IMatrix -> Slice -> IO MX
mx_indexed__2 x = casadi__MX__indexed__2 (castMX x)


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


-- classy wrapper
mx_indexed__3 :: MXClass a => a -> Slice -> IMatrix -> IO MX
mx_indexed__3 x = casadi__MX__indexed__3 (castMX x)


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


-- classy wrapper
mx_indexed__4 :: MXClass a => a -> Sparsity -> IO MX
mx_indexed__4 x = casadi__MX__indexed__4 (castMX x)


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


-- classy wrapper
mx_indexed__5 :: MXClass a => a -> IMatrix -> IO MX
mx_indexed__5 x = casadi__MX__indexed__5 (castMX x)


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


-- classy wrapper
mx_indexed__6 :: MXClass a => a -> Slice -> Slice -> IO MX
mx_indexed__6 x = casadi__MX__indexed__6 (castMX x)


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


-- classy wrapper
mx_indexed_assignment__0 :: MXClass a => a -> Slice -> MX -> IO ()
mx_indexed_assignment__0 x = casadi__MX__indexed_assignment__0 (castMX x)


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


-- classy wrapper
mx_indexed_assignment__1 :: MXClass a => a -> IMatrix -> IMatrix -> MX -> IO ()
mx_indexed_assignment__1 x = casadi__MX__indexed_assignment__1 (castMX x)


-- direct wrapper
foreign import ccall unsafe "casadi__MX__indexed_assignment__2" c_casadi__MX__indexed_assignment__2
  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr Slice' -> Ptr IMatrix' -> Ptr MX' -> IO ()
casadi__MX__indexed_assignment__2
  :: MX -> Slice -> IMatrix -> MX -> IO ()
casadi__MX__indexed_assignment__2 x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__MX__indexed_assignment__2 errStrPtrP x0' x1' x2' x3'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
mx_indexed_assignment__2 :: MXClass a => a -> Slice -> IMatrix -> MX -> IO ()
mx_indexed_assignment__2 x = casadi__MX__indexed_assignment__2 (castMX x)


-- direct wrapper
foreign import ccall unsafe "casadi__MX__indexed_assignment__3" c_casadi__MX__indexed_assignment__3
  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr IMatrix' -> Ptr Slice' -> Ptr MX' -> IO ()
casadi__MX__indexed_assignment__3
  :: MX -> IMatrix -> Slice -> MX -> IO ()
casadi__MX__indexed_assignment__3 x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__MX__indexed_assignment__3 errStrPtrP x0' x1' x2' x3'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
mx_indexed_assignment__3 :: MXClass a => a -> IMatrix -> Slice -> MX -> IO ()
mx_indexed_assignment__3 x = casadi__MX__indexed_assignment__3 (castMX x)


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


-- classy wrapper
mx_indexed_assignment__4 :: MXClass a => a -> Sparsity -> MX -> IO ()
mx_indexed_assignment__4 x = casadi__MX__indexed_assignment__4 (castMX x)


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


-- classy wrapper
mx_indexed_assignment__5 :: MXClass a => a -> Slice -> Slice -> MX -> IO ()
mx_indexed_assignment__5 x = casadi__MX__indexed_assignment__5 (castMX x)


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


-- classy wrapper
mx_indexed_one_based__0 :: MXClass a => a -> Int -> IO MX
mx_indexed_one_based__0 x = casadi__MX__indexed_one_based__0 (castMX x)


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


-- classy wrapper
mx_indexed_one_based__1 :: MXClass a => a -> Int -> Int -> IO MX
mx_indexed_one_based__1 x = casadi__MX__indexed_one_based__1 (castMX x)


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


-- classy wrapper
mx_indexed_one_based_assignment__0 :: MXClass a => a -> Int -> MX -> IO ()
mx_indexed_one_based_assignment__0 x = casadi__MX__indexed_one_based_assignment__0 (castMX x)


-- direct wrapper
foreign import ccall unsafe "casadi__MX__indexed_one_based_assignment__1" c_casadi__MX__indexed_one_based_assignment__1
  :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> CInt -> Ptr MX' -> IO ()
casadi__MX__indexed_one_based_assignment__1
  :: MX -> Int -> Int -> MX -> IO ()
casadi__MX__indexed_one_based_assignment__1 x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__MX__indexed_one_based_assignment__1 errStrPtrP x0' x1' x2' x3'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
mx_indexed_one_based_assignment__1 :: MXClass a => a -> Int -> Int -> MX -> IO ()
mx_indexed_one_based_assignment__1 x = casadi__MX__indexed_one_based_assignment__1 (castMX x)


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


-- classy wrapper
mx_indexed_zero_based__0 :: MXClass a => a -> Int -> IO MX
mx_indexed_zero_based__0 x = casadi__MX__indexed_zero_based__0 (castMX x)


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


-- classy wrapper
mx_indexed_zero_based__1 :: MXClass a => a -> Int -> Int -> IO MX
mx_indexed_zero_based__1 x = casadi__MX__indexed_zero_based__1 (castMX x)


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


-- classy wrapper
mx_indexed_zero_based_assignment__0 :: MXClass a => a -> Int -> MX -> IO ()
mx_indexed_zero_based_assignment__0 x = casadi__MX__indexed_zero_based_assignment__0 (castMX x)


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


-- classy wrapper
mx_indexed_zero_based_assignment__1 :: MXClass a => a -> IMatrix -> MX -> IO ()
mx_indexed_zero_based_assignment__1 x = casadi__MX__indexed_zero_based_assignment__1 (castMX x)


-- direct wrapper
foreign import ccall unsafe "casadi__MX__indexed_zero_based_assignment__2" c_casadi__MX__indexed_zero_based_assignment__2
  :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> CInt -> Ptr MX' -> IO ()
casadi__MX__indexed_zero_based_assignment__2
  :: MX -> Int -> Int -> MX -> IO ()
casadi__MX__indexed_zero_based_assignment__2 x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__MX__indexed_zero_based_assignment__2 errStrPtrP x0' x1' x2' x3'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
mx_indexed_zero_based_assignment__2 :: MXClass a => a -> Int -> Int -> MX -> IO ()
mx_indexed_zero_based_assignment__2 x = casadi__MX__indexed_zero_based_assignment__2 (castMX x)


-- direct wrapper
foreign import ccall unsafe "casadi__MX__inf__0" c_casadi__MX__inf__0
  :: Ptr (Ptr StdString) -> IO (Ptr MX')
casadi__MX__inf__0
  :: IO MX
casadi__MX__inf__0  =

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


-- classy wrapper
mx_inf__0 :: IO MX
mx_inf__0 = casadi__MX__inf__0


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


-- classy wrapper
mx_inf__1 :: Int -> IO MX
mx_inf__1 = casadi__MX__inf__1


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


-- classy wrapper
mx_inf__2 :: Int -> Int -> IO MX
mx_inf__2 = casadi__MX__inf__2


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


-- classy wrapper
mx_inf__3 :: Sparsity -> IO MX
mx_inf__3 = casadi__MX__inf__3


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


-- classy wrapper
mx_inner_prod :: MXClass a => a -> MX -> IO MX
mx_inner_prod x = casadi__MX__inner_prod (castMX x)


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


-- classy wrapper
mx_isBinary :: MXClass a => a -> IO Bool
mx_isBinary x = casadi__MX__isBinary (castMX x)


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


-- classy wrapper
mx_isCommutative :: MXClass a => a -> IO Bool
mx_isCommutative x = casadi__MX__isCommutative (castMX x)


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


-- classy wrapper
mx_isConstant :: MXClass a => a -> IO Bool
mx_isConstant x = casadi__MX__isConstant (castMX x)


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


-- classy wrapper
mx_isDense :: MXClass a => a -> IO Bool
mx_isDense x = casadi__MX__isDense (castMX x)


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


-- classy wrapper
mx_isEmpty__0 :: MXClass a => a -> IO Bool
mx_isEmpty__0 x = casadi__MX__isEmpty__0 (castMX x)


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


-- classy wrapper
mx_isEmpty__1 :: MXClass a => a -> Bool -> IO Bool
mx_isEmpty__1 x = casadi__MX__isEmpty__1 (castMX x)


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


-- classy wrapper
mx_isEqual__0 :: MXClass a => a -> MX -> IO Bool
mx_isEqual__0 x = casadi__MX__isEqual__0 (castMX x)


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


-- classy wrapper
mx_isEqual__1 :: MXClass a => a -> MX -> Int -> IO Bool
mx_isEqual__1 x = casadi__MX__isEqual__1 (castMX x)


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


-- classy wrapper
mx_isEvaluation :: MXClass a => a -> IO Bool
mx_isEvaluation x = casadi__MX__isEvaluation (castMX x)


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


-- classy wrapper
mx_isEvaluationOutput :: MXClass a => a -> IO Bool
mx_isEvaluationOutput x = casadi__MX__isEvaluationOutput (castMX x)


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


-- classy wrapper
mx_isIdentity :: MXClass a => a -> IO Bool
mx_isIdentity x = casadi__MX__isIdentity (castMX x)


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


-- classy wrapper
mx_isMinusOne :: MXClass a => a -> IO Bool
mx_isMinusOne x = casadi__MX__isMinusOne (castMX x)


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


-- classy wrapper
mx_isMultiplication :: MXClass a => a -> IO Bool
mx_isMultiplication x = casadi__MX__isMultiplication (castMX x)


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


-- classy wrapper
mx_isNorm :: MXClass a => a -> IO Bool
mx_isNorm x = casadi__MX__isNorm (castMX x)


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


-- classy wrapper
mx_isOne :: MXClass a => a -> IO Bool
mx_isOne x = casadi__MX__isOne (castMX x)


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


-- classy wrapper
mx_isOperation :: MXClass a => a -> Int -> IO Bool
mx_isOperation x = casadi__MX__isOperation (castMX x)


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


-- classy wrapper
mx_isRegular :: MXClass a => a -> IO Bool
mx_isRegular x = casadi__MX__isRegular (castMX x)


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


-- classy wrapper
mx_isScalar__0 :: MXClass a => a -> IO Bool
mx_isScalar__0 x = casadi__MX__isScalar__0 (castMX x)


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


-- classy wrapper
mx_isScalar__1 :: MXClass a => a -> Bool -> IO Bool
mx_isScalar__1 x = casadi__MX__isScalar__1 (castMX x)


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


-- classy wrapper
mx_isSquare :: MXClass a => a -> IO Bool
mx_isSquare x = casadi__MX__isSquare (castMX x)


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


-- classy wrapper
mx_isSymbolic :: MXClass a => a -> IO Bool
mx_isSymbolic x = casadi__MX__isSymbolic (castMX x)


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


-- classy wrapper
mx_isSymbolicSparse :: MXClass a => a -> IO Bool
mx_isSymbolicSparse x = casadi__MX__isSymbolicSparse (castMX x)


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


-- classy wrapper
mx_isTranspose :: MXClass a => a -> IO Bool
mx_isTranspose x = casadi__MX__isTranspose (castMX x)


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


-- classy wrapper
mx_isTril :: MXClass a => a -> IO Bool
mx_isTril x = casadi__MX__isTril (castMX x)


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


-- classy wrapper
mx_isTriu :: MXClass a => a -> IO Bool
mx_isTriu x = casadi__MX__isTriu (castMX x)


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


-- classy wrapper
mx_isUnary :: MXClass a => a -> IO Bool
mx_isUnary x = casadi__MX__isUnary (castMX x)


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


-- classy wrapper
mx_isVector :: MXClass a => a -> IO Bool
mx_isVector x = casadi__MX__isVector (castMX x)


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


-- classy wrapper
mx_isZero :: MXClass a => a -> IO Bool
mx_isZero x = casadi__MX__isZero (castMX x)


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


-- classy wrapper
mx_lift :: MXClass a => a -> MX -> IO ()
mx_lift x = casadi__MX__lift (castMX x)


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


-- classy wrapper
mx_log :: MXClass a => a -> IO MX
mx_log x = casadi__MX__log (castMX x)


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


-- classy wrapper
mx_log10 :: MXClass a => a -> IO MX
mx_log10 x = casadi__MX__log10 (castMX x)


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


-- classy wrapper
mx_logic_and :: MXClass a => a -> MX -> IO MX
mx_logic_and x = casadi__MX__logic_and (castMX x)


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


-- classy wrapper
mx_logic_not :: MXClass a => a -> IO MX
mx_logic_not x = casadi__MX__logic_not (castMX x)


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


-- classy wrapper
mx_logic_or :: MXClass a => a -> MX -> IO MX
mx_logic_or x = casadi__MX__logic_or (castMX x)


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


-- classy wrapper
mx_mapping :: MXClass a => a -> IO IMatrix
mx_mapping x = casadi__MX__mapping (castMX x)


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


-- classy wrapper
mx_mul__0 :: MXClass a => a -> MX -> IO MX
mx_mul__0 x = casadi__MX__mul__0 (castMX x)


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


-- classy wrapper
mx_mul__1 :: MXClass a => a -> MX -> Sparsity -> IO MX
mx_mul__1 x = casadi__MX__mul__1 (castMX x)


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


-- classy wrapper
mx_mul_full__0 :: MXClass a => a -> MX -> IO MX
mx_mul_full__0 x = casadi__MX__mul_full__0 (castMX x)


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


-- classy wrapper
mx_mul_full__1 :: MXClass a => a -> MX -> Sparsity -> IO MX
mx_mul_full__1 x = casadi__MX__mul_full__1 (castMX x)


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


-- classy wrapper
mx_mul_smart :: MXClass a => a -> MX -> Sparsity -> IO MX
mx_mul_smart x = casadi__MX__mul_smart (castMX x)


-- direct wrapper
foreign import ccall unsafe "casadi__MX__nan__0" c_casadi__MX__nan__0
  :: Ptr (Ptr StdString) -> IO (Ptr MX')
casadi__MX__nan__0
  :: IO MX
casadi__MX__nan__0  =

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


-- classy wrapper
mx_nan__0 :: IO MX
mx_nan__0 = casadi__MX__nan__0


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


-- classy wrapper
mx_nan__1 :: Int -> IO MX
mx_nan__1 = casadi__MX__nan__1


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


-- classy wrapper
mx_nan__2 :: Int -> Int -> IO MX
mx_nan__2 = casadi__MX__nan__2


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


-- classy wrapper
mx_nan__3 :: Sparsity -> IO MX
mx_nan__3 = casadi__MX__nan__3


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


-- classy wrapper
mx_numel :: MXClass a => a -> IO Int
mx_numel x = casadi__MX__numel (castMX x)


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


-- classy wrapper
mx_nz_indexed__0 :: MXClass a => a -> IMatrix -> IO MX
mx_nz_indexed__0 x = casadi__MX__nz_indexed__0 (castMX x)


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


-- classy wrapper
mx_nz_indexed__1 :: MXClass a => a -> Slice -> IO MX
mx_nz_indexed__1 x = casadi__MX__nz_indexed__1 (castMX x)


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


-- classy wrapper
mx_nz_indexed_assignment__0 :: MXClass a => a -> IMatrix -> MX -> IO ()
mx_nz_indexed_assignment__0 x = casadi__MX__nz_indexed_assignment__0 (castMX x)


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


-- classy wrapper
mx_nz_indexed_assignment__1 :: MXClass a => a -> Slice -> MX -> IO ()
mx_nz_indexed_assignment__1 x = casadi__MX__nz_indexed_assignment__1 (castMX x)


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


-- classy wrapper
mx_nz_indexed_one_based :: MXClass a => a -> Int -> IO MX
mx_nz_indexed_one_based x = casadi__MX__nz_indexed_one_based (castMX x)


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


-- classy wrapper
mx_nz_indexed_one_based_assignment :: MXClass a => a -> Int -> MX -> IO ()
mx_nz_indexed_one_based_assignment x = casadi__MX__nz_indexed_one_based_assignment (castMX x)


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


-- classy wrapper
mx_nz_indexed_zero_based :: MXClass a => a -> Int -> IO MX
mx_nz_indexed_zero_based x = casadi__MX__nz_indexed_zero_based (castMX x)


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


-- classy wrapper
mx_nz_indexed_zero_based_assignment :: MXClass a => a -> Int -> MX -> IO ()
mx_nz_indexed_zero_based_assignment x = casadi__MX__nz_indexed_zero_based_assignment (castMX x)


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


-- classy wrapper
mx_ones__0 :: Sparsity -> IO MX
mx_ones__0 = casadi__MX__ones__0


-- direct wrapper
foreign import ccall unsafe "casadi__MX__ones__1" c_casadi__MX__ones__1
  :: Ptr (Ptr StdString) -> IO (Ptr MX')
casadi__MX__ones__1
  :: IO MX
casadi__MX__ones__1  =

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


-- classy wrapper
mx_ones__1 :: IO MX
mx_ones__1 = casadi__MX__ones__1


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


-- classy wrapper
mx_ones__2 :: Int -> IO MX
mx_ones__2 = casadi__MX__ones__2


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


-- classy wrapper
mx_ones__3 :: Int -> Int -> IO MX
mx_ones__3 = casadi__MX__ones__3


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


-- classy wrapper
mx_outer_prod :: MXClass a => a -> MX -> IO MX
mx_outer_prod x = casadi__MX__outer_prod (castMX x)


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


-- classy wrapper
mx_printme :: MXClass a => a -> MX -> IO MX
mx_printme x = casadi__MX__printme (castMX x)


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


-- classy wrapper
mx_repmat__0 :: MX -> Int -> IO MX
mx_repmat__0 = casadi__MX__repmat__0


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


-- classy wrapper
mx_repmat__1 :: MX -> Int -> Int -> IO MX
mx_repmat__1 = casadi__MX__repmat__1


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


-- classy wrapper
mx_repmat__2 :: MX -> Sparsity -> IO MX
mx_repmat__2 = casadi__MX__repmat__2


-- direct wrapper
foreign import ccall unsafe "casadi__MX__setEqualityCheckingDepth__0" c_casadi__MX__setEqualityCheckingDepth__0
  :: Ptr (Ptr StdString) -> IO ()
casadi__MX__setEqualityCheckingDepth__0
  :: IO ()
casadi__MX__setEqualityCheckingDepth__0  =

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


-- classy wrapper
mx_setEqualityCheckingDepth__0 :: IO ()
mx_setEqualityCheckingDepth__0 = casadi__MX__setEqualityCheckingDepth__0


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


-- classy wrapper
mx_setEqualityCheckingDepth__1 :: Int -> IO ()
mx_setEqualityCheckingDepth__1 = casadi__MX__setEqualityCheckingDepth__1


-- direct wrapper
foreign import ccall unsafe "casadi__MX__setMaxNumCallsInPrint__0" c_casadi__MX__setMaxNumCallsInPrint__0
  :: Ptr (Ptr StdString) -> IO ()
casadi__MX__setMaxNumCallsInPrint__0
  :: IO ()
casadi__MX__setMaxNumCallsInPrint__0  =

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


-- classy wrapper
mx_setMaxNumCallsInPrint__0 :: IO ()
mx_setMaxNumCallsInPrint__0 = casadi__MX__setMaxNumCallsInPrint__0


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


-- classy wrapper
mx_setMaxNumCallsInPrint__1 :: Int -> IO ()
mx_setMaxNumCallsInPrint__1 = casadi__MX__setMaxNumCallsInPrint__1


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


-- classy wrapper
mx_setNZ__0 :: MXClass a => a -> IMatrix -> MX -> IO ()
mx_setNZ__0 x = casadi__MX__setNZ__0 (castMX x)


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


-- classy wrapper
mx_setNZ__1 :: MXClass a => a -> Slice -> MX -> IO ()
mx_setNZ__1 x = casadi__MX__setNZ__1 (castMX x)


-- direct wrapper
foreign import ccall unsafe "casadi__MX__setNZ__2" c_casadi__MX__setNZ__2
  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (StdVec CInt) -> Ptr MX' -> IO ()
casadi__MX__setNZ__2
  :: MX -> Vector Int -> MX -> IO ()
casadi__MX__setNZ__2 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__MX__setNZ__2 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
mx_setNZ__2 :: MXClass a => a -> Vector Int -> MX -> IO ()
mx_setNZ__2 x = casadi__MX__setNZ__2 (castMX x)


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


-- classy wrapper
mx_setNZ__3 :: MXClass a => a -> Int -> MX -> IO ()
mx_setNZ__3 x = casadi__MX__setNZ__3 (castMX x)


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


-- classy wrapper
mx_setSparse__0 :: MXClass a => a -> Sparsity -> IO MX
mx_setSparse__0 x = casadi__MX__setSparse__0 (castMX x)


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


-- classy wrapper
mx_setSparse__1 :: MXClass a => a -> Sparsity -> Bool -> IO MX
mx_setSparse__1 x = casadi__MX__setSparse__1 (castMX x)


-- direct wrapper
foreign import ccall unsafe "casadi__MX__setSub__0" c_casadi__MX__setSub__0
  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> Ptr Sparsity' -> CInt -> IO ()
casadi__MX__setSub__0
  :: MX -> MX -> Sparsity -> Int -> IO ()
casadi__MX__setSub__0 x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__MX__setSub__0 errStrPtrP x0' x1' x2' x3'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
mx_setSub__0 :: MXClass a => a -> MX -> Sparsity -> Int -> IO ()
mx_setSub__0 x = casadi__MX__setSub__0 (castMX x)


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


-- classy wrapper
mx_setSub__1 :: MXClass a => a -> MX -> IMatrix -> IMatrix -> IO ()
mx_setSub__1 x = casadi__MX__setSub__1 (castMX x)


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


-- classy wrapper
mx_setSub__2 :: MXClass a => a -> MX -> Slice -> Slice -> IO ()
mx_setSub__2 x = casadi__MX__setSub__2 (castMX x)


-- direct wrapper
foreign import ccall unsafe "casadi__MX__setSub__3" c_casadi__MX__setSub__3
  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> Ptr IMatrix' -> IO ()
casadi__MX__setSub__3
  :: MX -> MX -> Int -> IMatrix -> IO ()
casadi__MX__setSub__3 x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__MX__setSub__3 errStrPtrP x0' x1' x2' x3'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
mx_setSub__3 :: MXClass a => a -> MX -> Int -> IMatrix -> IO ()
mx_setSub__3 x = casadi__MX__setSub__3 (castMX x)


-- direct wrapper
foreign import ccall unsafe "casadi__MX__setSub__4" c_casadi__MX__setSub__4
  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> Ptr (StdVec CInt) -> Ptr IMatrix' -> IO ()
casadi__MX__setSub__4
  :: MX -> MX -> Vector Int -> IMatrix -> IO ()
casadi__MX__setSub__4 x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__MX__setSub__4 errStrPtrP x0' x1' x2' x3'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
mx_setSub__4 :: MXClass a => a -> MX -> Vector Int -> IMatrix -> IO ()
mx_setSub__4 x = casadi__MX__setSub__4 (castMX x)


-- direct wrapper
foreign import ccall unsafe "casadi__MX__setSub__5" c_casadi__MX__setSub__5
  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> Ptr IMatrix' -> CInt -> IO ()
casadi__MX__setSub__5
  :: MX -> MX -> IMatrix -> Int -> IO ()
casadi__MX__setSub__5 x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__MX__setSub__5 errStrPtrP x0' x1' x2' x3'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
mx_setSub__5 :: MXClass a => a -> MX -> IMatrix -> Int -> IO ()
mx_setSub__5 x = casadi__MX__setSub__5 (castMX x)


-- direct wrapper
foreign import ccall unsafe "casadi__MX__setSub__6" c_casadi__MX__setSub__6
  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> Ptr IMatrix' -> Ptr (StdVec CInt) -> IO ()
casadi__MX__setSub__6
  :: MX -> MX -> IMatrix -> Vector Int -> IO ()
casadi__MX__setSub__6 x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__MX__setSub__6 errStrPtrP x0' x1' x2' x3'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
mx_setSub__6 :: MXClass a => a -> MX -> IMatrix -> Vector Int -> IO ()
mx_setSub__6 x = casadi__MX__setSub__6 (castMX x)


-- direct wrapper
foreign import ccall unsafe "casadi__MX__setSub__7" c_casadi__MX__setSub__7
  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> Ptr (StdVec CInt) -> Ptr Slice' -> IO ()
casadi__MX__setSub__7
  :: MX -> MX -> Vector Int -> Slice -> IO ()
casadi__MX__setSub__7 x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__MX__setSub__7 errStrPtrP x0' x1' x2' x3'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
mx_setSub__7 :: MXClass a => a -> MX -> Vector Int -> Slice -> IO ()
mx_setSub__7 x = casadi__MX__setSub__7 (castMX x)


-- direct wrapper
foreign import ccall unsafe "casadi__MX__setSub__8" c_casadi__MX__setSub__8
  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO ()
casadi__MX__setSub__8
  :: MX -> MX -> Vector Int -> Vector Int -> IO ()
casadi__MX__setSub__8 x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__MX__setSub__8 errStrPtrP x0' x1' x2' x3'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
mx_setSub__8 :: MXClass a => a -> MX -> Vector Int -> Vector Int -> IO ()
mx_setSub__8 x = casadi__MX__setSub__8 (castMX x)


-- direct wrapper
foreign import ccall unsafe "casadi__MX__setSub__9" c_casadi__MX__setSub__9
  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> Ptr (StdVec CInt) -> IO ()
casadi__MX__setSub__9
  :: MX -> MX -> Int -> Vector Int -> IO ()
casadi__MX__setSub__9 x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__MX__setSub__9 errStrPtrP x0' x1' x2' x3'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
mx_setSub__9 :: MXClass a => a -> MX -> Int -> Vector Int -> IO ()
mx_setSub__9 x = casadi__MX__setSub__9 (castMX x)


-- direct wrapper
foreign import ccall unsafe "casadi__MX__setSub__10" c_casadi__MX__setSub__10
  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> Ptr (StdVec CInt) -> CInt -> IO ()
casadi__MX__setSub__10
  :: MX -> MX -> Vector Int -> Int -> IO ()
casadi__MX__setSub__10 x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__MX__setSub__10 errStrPtrP x0' x1' x2' x3'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
mx_setSub__10 :: MXClass a => a -> MX -> Vector Int -> Int -> IO ()
mx_setSub__10 x = casadi__MX__setSub__10 (castMX x)


-- direct wrapper
foreign import ccall unsafe "casadi__MX__setSub__11" c_casadi__MX__setSub__11
  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> CInt -> IO ()
casadi__MX__setSub__11
  :: MX -> MX -> Int -> Int -> IO ()
casadi__MX__setSub__11 x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__MX__setSub__11 errStrPtrP x0' x1' x2' x3'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
mx_setSub__11 :: MXClass a => a -> MX -> Int -> Int -> IO ()
mx_setSub__11 x = casadi__MX__setSub__11 (castMX x)


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


-- classy wrapper
mx_setTemp :: MXClass a => a -> Int -> IO ()
mx_setTemp x = casadi__MX__setTemp (castMX x)


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


-- classy wrapper
mx_sign :: MXClass a => a -> IO MX
mx_sign x = casadi__MX__sign (castMX x)


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


-- classy wrapper
mx_sin :: MXClass a => a -> IO MX
mx_sin x = casadi__MX__sin (castMX x)


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


-- classy wrapper
mx_sinh :: MXClass a => a -> IO MX
mx_sinh x = casadi__MX__sinh (castMX x)


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


-- classy wrapper
mx_size__0 :: MXClass a => a -> SparsityType -> IO Int
mx_size__0 x = casadi__MX__size__0 (castMX x)


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


-- classy wrapper
mx_size__1 :: MXClass a => a -> IO Int
mx_size__1 x = casadi__MX__size__1 (castMX x)


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


-- classy wrapper
mx_size1 :: MXClass a => a -> IO Int
mx_size1 x = casadi__MX__size1 (castMX x)


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


-- classy wrapper
mx_size2 :: MXClass a => a -> IO Int
mx_size2 x = casadi__MX__size2 (castMX x)


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


-- classy wrapper
mx_sizeD :: MXClass a => a -> IO Int
mx_sizeD x = casadi__MX__sizeD (castMX x)


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


-- classy wrapper
mx_sizeL :: MXClass a => a -> IO Int
mx_sizeL x = casadi__MX__sizeL (castMX x)


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


-- classy wrapper
mx_sizeU :: MXClass a => a -> IO Int
mx_sizeU x = casadi__MX__sizeU (castMX x)


-- direct wrapper
foreign import ccall unsafe "casadi__MX__sparse__0" c_casadi__MX__sparse__0
  :: Ptr (Ptr StdString) -> IO (Ptr MX')
casadi__MX__sparse__0
  :: IO MX
casadi__MX__sparse__0  =

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


-- classy wrapper
mx_sparse__0 :: IO MX
mx_sparse__0 = casadi__MX__sparse__0


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


-- classy wrapper
mx_sparse__1 :: Int -> IO MX
mx_sparse__1 = casadi__MX__sparse__1


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


-- classy wrapper
mx_sparse__2 :: Int -> Int -> IO MX
mx_sparse__2 = casadi__MX__sparse__2


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


-- classy wrapper
mx_sparsity__0 :: MXClass a => a -> IO Sparsity
mx_sparsity__0 x = casadi__MX__sparsity__0 (castMX x)


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


-- classy wrapper
mx_sparsity__1 :: MXClass a => a -> IO Sparsity
mx_sparsity__1 x = casadi__MX__sparsity__1 (castMX x)


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


-- classy wrapper
mx_sparsityRef__0 :: MXClass a => a -> IO Sparsity
mx_sparsityRef__0 x = casadi__MX__sparsityRef__0 (castMX x)


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


-- classy wrapper
mx_sparsityRef__1 :: MXClass a => a -> IO Sparsity
mx_sparsityRef__1 x = casadi__MX__sparsityRef__1 (castMX x)


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


-- classy wrapper
mx_sqrt :: MXClass a => a -> IO MX
mx_sqrt x = casadi__MX__sqrt (castMX x)


-- direct wrapper
foreign import ccall unsafe "casadi__MX__sub__0" c_casadi__MX__sub__0
  :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> Ptr IMatrix' -> IO (Ptr MX')
casadi__MX__sub__0
  :: MX -> Int -> IMatrix -> IO MX
casadi__MX__sub__0 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__MX__sub__0 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
mx_sub__0 :: MXClass a => a -> Int -> IMatrix -> IO MX
mx_sub__0 x = casadi__MX__sub__0 (castMX x)


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


-- classy wrapper
mx_sub__1 :: MXClass a => a -> IMatrix -> IMatrix -> IO MX
mx_sub__1 x = casadi__MX__sub__1 (castMX x)


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


-- classy wrapper
mx_sub__2 :: MXClass a => a -> Slice -> IMatrix -> IO MX
mx_sub__2 x = casadi__MX__sub__2 (castMX x)


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


-- classy wrapper
mx_sub__3 :: MXClass a => a -> IMatrix -> Slice -> IO MX
mx_sub__3 x = casadi__MX__sub__3 (castMX x)


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


-- classy wrapper
mx_sub__4 :: MXClass a => a -> Slice -> Slice -> IO MX
mx_sub__4 x = casadi__MX__sub__4 (castMX x)


-- direct wrapper
foreign import ccall unsafe "casadi__MX__sub__5" c_casadi__MX__sub__5
  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr Slice' -> CInt -> IO (Ptr MX')
casadi__MX__sub__5
  :: MX -> Slice -> Int -> IO MX
casadi__MX__sub__5 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__MX__sub__5 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
mx_sub__5 :: MXClass a => a -> Slice -> Int -> IO MX
mx_sub__5 x = casadi__MX__sub__5 (castMX x)


-- direct wrapper
foreign import ccall unsafe "casadi__MX__sub__6" c_casadi__MX__sub__6
  :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> Ptr Slice' -> IO (Ptr MX')
casadi__MX__sub__6
  :: MX -> Int -> Slice -> IO MX
casadi__MX__sub__6 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__MX__sub__6 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
mx_sub__6 :: MXClass a => a -> Int -> Slice -> IO MX
mx_sub__6 x = casadi__MX__sub__6 (castMX x)


-- direct wrapper
foreign import ccall unsafe "casadi__MX__sub__7" c_casadi__MX__sub__7
  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (StdVec CInt) -> Ptr IMatrix' -> IO (Ptr MX')
casadi__MX__sub__7
  :: MX -> Vector Int -> IMatrix -> IO MX
casadi__MX__sub__7 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__MX__sub__7 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
mx_sub__7 :: MXClass a => a -> Vector Int -> IMatrix -> IO MX
mx_sub__7 x = casadi__MX__sub__7 (castMX x)


-- direct wrapper
foreign import ccall unsafe "casadi__MX__sub__8" c_casadi__MX__sub__8
  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr IMatrix' -> Ptr (StdVec CInt) -> IO (Ptr MX')
casadi__MX__sub__8
  :: MX -> IMatrix -> Vector Int -> IO MX
casadi__MX__sub__8 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__MX__sub__8 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
mx_sub__8 :: MXClass a => a -> IMatrix -> Vector Int -> IO MX
mx_sub__8 x = casadi__MX__sub__8 (castMX x)


-- direct wrapper
foreign import ccall unsafe "casadi__MX__sub__9" c_casadi__MX__sub__9
  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr IMatrix' -> CInt -> IO (Ptr MX')
casadi__MX__sub__9
  :: MX -> IMatrix -> Int -> IO MX
casadi__MX__sub__9 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__MX__sub__9 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
mx_sub__9 :: MXClass a => a -> IMatrix -> Int -> IO MX
mx_sub__9 x = casadi__MX__sub__9 (castMX x)


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


-- classy wrapper
mx_sub__10 :: MXClass a => a -> Sparsity -> IO MX
mx_sub__10 x = casadi__MX__sub__10 (castMX x)


-- direct wrapper
foreign import ccall unsafe "casadi__MX__sub__11" c_casadi__MX__sub__11
  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr Sparsity' -> CInt -> IO (Ptr MX')
casadi__MX__sub__11
  :: MX -> Sparsity -> Int -> IO MX
casadi__MX__sub__11 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__MX__sub__11 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
mx_sub__11 :: MXClass a => a -> Sparsity -> Int -> IO MX
mx_sub__11 x = casadi__MX__sub__11 (castMX x)


-- direct wrapper
foreign import ccall unsafe "casadi__MX__sub__12" c_casadi__MX__sub__12
  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO (Ptr MX')
casadi__MX__sub__12
  :: MX -> Vector Int -> Vector Int -> IO MX
casadi__MX__sub__12 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__MX__sub__12 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
mx_sub__12 :: MXClass a => a -> Vector Int -> Vector Int -> IO MX
mx_sub__12 x = casadi__MX__sub__12 (castMX x)


-- direct wrapper
foreign import ccall unsafe "casadi__MX__sub__13" c_casadi__MX__sub__13
  :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> Ptr (StdVec CInt) -> IO (Ptr MX')
casadi__MX__sub__13
  :: MX -> Int -> Vector Int -> IO MX
casadi__MX__sub__13 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__MX__sub__13 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
mx_sub__13 :: MXClass a => a -> Int -> Vector Int -> IO MX
mx_sub__13 x = casadi__MX__sub__13 (castMX x)


-- direct wrapper
foreign import ccall unsafe "casadi__MX__sub__14" c_casadi__MX__sub__14
  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (StdVec CInt) -> CInt -> IO (Ptr MX')
casadi__MX__sub__14
  :: MX -> Vector Int -> Int -> IO MX
casadi__MX__sub__14 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__MX__sub__14 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
mx_sub__14 :: MXClass a => a -> Vector Int -> Int -> IO MX
mx_sub__14 x = casadi__MX__sub__14 (castMX x)


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


-- classy wrapper
mx_sub__15 :: MXClass a => a -> Int -> Int -> IO MX
mx_sub__15 x = casadi__MX__sub__15 (castMX x)


-- direct wrapper
foreign import ccall unsafe "casadi__MX__sym__0" c_casadi__MX__sym__0
  :: Ptr (Ptr StdString) -> Ptr StdString -> CInt -> CInt -> CInt -> CInt -> IO (Ptr (StdVec (Ptr (StdVec (Ptr MX')))))
casadi__MX__sym__0
  :: String -> Int -> Int -> Int -> Int -> IO (Vector (Vector MX))
casadi__MX__sym__0 x0 x1 x2 x3 x4 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__MX__sym__0 errStrPtrP x0' x1' x2' x3' x4'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
mx_sym__0 :: String -> Int -> Int -> Int -> Int -> IO (Vector (Vector MX))
mx_sym__0 = casadi__MX__sym__0


-- direct wrapper
foreign import ccall unsafe "casadi__MX__sym__1" c_casadi__MX__sym__1
  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> CInt -> CInt -> IO (Ptr (StdVec (Ptr (StdVec (Ptr MX')))))
casadi__MX__sym__1
  :: String -> Sparsity -> Int -> Int -> IO (Vector (Vector MX))
casadi__MX__sym__1 x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__MX__sym__1 errStrPtrP x0' x1' x2' x3'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
mx_sym__1 :: String -> Sparsity -> Int -> Int -> IO (Vector (Vector MX))
mx_sym__1 = casadi__MX__sym__1


-- direct wrapper
foreign import ccall unsafe "casadi__MX__sym__2" c_casadi__MX__sym__2
  :: Ptr (Ptr StdString) -> Ptr StdString -> CInt -> CInt -> CInt -> IO (Ptr (StdVec (Ptr MX')))
casadi__MX__sym__2
  :: String -> Int -> Int -> Int -> IO (Vector MX)
casadi__MX__sym__2 x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__MX__sym__2 errStrPtrP x0' x1' x2' x3'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
mx_sym__2 :: String -> Int -> Int -> Int -> IO (Vector MX)
mx_sym__2 = casadi__MX__sym__2


-- direct wrapper
foreign import ccall unsafe "casadi__MX__sym__3" c_casadi__MX__sym__3
  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> CInt -> IO (Ptr (StdVec (Ptr MX')))
casadi__MX__sym__3
  :: String -> Sparsity -> Int -> IO (Vector MX)
casadi__MX__sym__3 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__MX__sym__3 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
mx_sym__3 :: String -> Sparsity -> Int -> IO (Vector MX)
mx_sym__3 = casadi__MX__sym__3


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


-- classy wrapper
mx_sym__4 :: String -> Sparsity -> IO MX
mx_sym__4 = casadi__MX__sym__4


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


-- classy wrapper
mx_sym__5 :: String -> IO MX
mx_sym__5 = casadi__MX__sym__5


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


-- classy wrapper
mx_sym__6 :: String -> Int -> IO MX
mx_sym__6 = casadi__MX__sym__6


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


-- classy wrapper
mx_sym__7 :: String -> Int -> Int -> IO MX
mx_sym__7 = casadi__MX__sym__7


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


-- classy wrapper
mx_tan :: MXClass a => a -> IO MX
mx_tan x = casadi__MX__tan (castMX x)


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


-- classy wrapper
mx_tanh :: MXClass a => a -> IO MX
mx_tanh x = casadi__MX__tanh (castMX x)


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


-- classy wrapper
mx_trans :: MXClass a => a -> IO MX
mx_trans x = casadi__MX__trans (castMX x)


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


-- classy wrapper
mx_unary :: Int -> MX -> IO MX
mx_unary = casadi__MX__unary


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


-- classy wrapper
mx_zeros__0 :: Sparsity -> IO MX
mx_zeros__0 = casadi__MX__zeros__0


-- direct wrapper
foreign import ccall unsafe "casadi__MX__zeros__1" c_casadi__MX__zeros__1
  :: Ptr (Ptr StdString) -> IO (Ptr MX')
casadi__MX__zeros__1
  :: IO MX
casadi__MX__zeros__1  =

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


-- classy wrapper
mx_zeros__1 :: IO MX
mx_zeros__1 = casadi__MX__zeros__1


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


-- classy wrapper
mx_zeros__2 :: Int -> IO MX
mx_zeros__2 = casadi__MX__zeros__2


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


-- classy wrapper
mx_zeros__3 :: Int -> Int -> IO MX
mx_zeros__3 = casadi__MX__zeros__3