casadi-bindings-core-2.3.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_T,
         mx__0,
         mx__1,
         mx__2,
         mx__3,
         mx__4,
         mx__5,
         mx__6,
         mx__7,
         mx___constpow__,
         mx___copysign__,
         mx___hash__,
         mx___mldivide__,
         mx___mrdivide__,
         mx___nonzero__,
         mx___truediv____0,
         mx___truediv____1,
         mx_addToSum,
         mx_append,
         mx_appendColumns,
         mx_attachAssert__0,
         mx_attachAssert__1,
         mx_binary,
         mx_colind,
         mx_constpow,
         mx_dimString,
         mx_enlarge__0,
         mx_enlarge__1,
         mx_erase__0,
         mx_erase__1,
         mx_erase__2,
         mx_erase__3,
         mx_eye,
         mx_find__0,
         mx_find__1,
         mx_getColind,
         mx_getDep__0,
         mx_getDep__1,
         mx_getEqualityCheckingDepth,
         mx_getEvaluationOutput,
         mx_getFunction,
         mx_getMatrixValue,
         mx_getMaxNumCallsInPrint,
         mx_getNZ__0,
         mx_getNZ__1,
         mx_getName,
         mx_getNdeps,
         mx_getNumOutputs,
         mx_getOp,
         mx_getOutput__0,
         mx_getOutput__1,
         mx_getRow,
         mx_getSparsity,
         mx_getTemp,
         mx_getValue,
         mx_get__0,
         mx_get__1,
         mx_get__2,
         mx_get__3,
         mx_get__4,
         mx_get__5,
         mx_get__6,
         mx_inf__0,
         mx_inf__1,
         mx_inf__2,
         mx_inf__3,
         mx_isBinary,
         mx_isCommutative,
         mx_isConstant,
         mx_isDense,
         mx_isEmpty__0,
         mx_isEmpty__1,
         mx_isEvaluation,
         mx_isEvaluationOutput,
         mx_isIdentity,
         mx_isMinusOne,
         mx_isMultiplication,
         mx_isNorm,
         mx_isOne,
         mx_isOperation,
         mx_isRegular,
         mx_isRowVector,
         mx_isScalar__0,
         mx_isScalar__1,
         mx_isSquare,
         mx_isSymbolic,
         mx_isSymbolicSparse,
         mx_isTranspose,
         mx_isTril,
         mx_isTriu,
         mx_isUnary,
         mx_isVector__0,
         mx_isVector__1,
         mx_isZero,
         mx_lift,
         mx_makeDense__0,
         mx_makeDense__1,
         mx_mapping,
         mx_nan__0,
         mx_nan__1,
         mx_nan__2,
         mx_nan__3,
         mx_nnz,
         mx_numel__0,
         mx_numel__1,
         mx_ones__0,
         mx_ones__1,
         mx_ones__2,
         mx_ones__3,
         mx_operator_minus,
         mx_printme,
         mx_row,
         mx_setEqualityCheckingDepth__0,
         mx_setEqualityCheckingDepth__1,
         mx_setMaxNumCallsInPrint__0,
         mx_setMaxNumCallsInPrint__1,
         mx_setNZ__0,
         mx_setNZ__1,
         mx_setSparse__0,
         mx_setSparse__1,
         mx_setTemp,
         mx_set__0,
         mx_set__1,
         mx_set__2,
         mx_set__3,
         mx_set__4,
         mx_set__5,
         mx_set__6,
         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_sparse__3,
         mx_sparsity,
         mx_sparsityRef,
         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_unary,
         mx_zeros__0,
         mx_zeros__1,
         mx_zeros__2,
         mx_zeros__3,
         mx_zz_abs,
         mx_zz_acos,
         mx_zz_acosh,
         mx_zz_and,
         mx_zz_asin,
         mx_zz_asinh,
         mx_zz_atan,
         mx_zz_atan2,
         mx_zz_atanh,
         mx_zz_blockcat,
         mx_zz_blocksplit,
         mx_zz_ceil,
         mx_zz_cos,
         mx_zz_cosh,
         mx_zz_countNodes,
         mx_zz_createParent__0,
         mx_zz_createParent__1,
         mx_zz_createParent__2,
         mx_zz_cross__0,
         mx_zz_cross__1,
         mx_zz_densify,
         mx_zz_dependsOn,
         mx_zz_det,
         mx_zz_diag,
         mx_zz_diagcat,
         mx_zz_diagsplit,
         mx_zz_eq,
         mx_zz_erf,
         mx_zz_erfinv,
         mx_zz_exp,
         mx_zz_extractShared__0,
         mx_zz_extractShared__1,
         mx_zz_extractShared__2,
         mx_zz_floor,
         mx_zz_ge,
         mx_zz_getOperatorRepresentation,
         mx_zz_getSymbols__0,
         mx_zz_getSymbols__1,
         mx_zz_gradient,
         mx_zz_graph_substitute__0,
         mx_zz_graph_substitute__1,
         mx_zz_gt,
         mx_zz_horzcat,
         mx_zz_horzsplit,
         mx_zz_if_else,
         mx_zz_if_else_zero,
         mx_zz_inner_prod,
         mx_zz_inv,
         mx_zz_isEqual__0,
         mx_zz_isEqual__1,
         mx_zz_jacobian,
         mx_zz_kron,
         mx_zz_le,
         mx_zz_linspace,
         mx_zz_log,
         mx_zz_log10,
         mx_zz_lt,
         mx_zz_matrix_expand__0,
         mx_zz_matrix_expand__1,
         mx_zz_matrix_expand__2,
         mx_zz_matrix_expand__3,
         mx_zz_max,
         mx_zz_min,
         mx_zz_minus,
         mx_zz_mod,
         mx_zz_mpower,
         mx_zz_mtimes__0,
         mx_zz_mtimes__1,
         mx_zz_ne,
         mx_zz_norm_0_mul,
         mx_zz_norm_1,
         mx_zz_norm_2,
         mx_zz_norm_F,
         mx_zz_norm_inf,
         mx_zz_not,
         mx_zz_nullspace,
         mx_zz_or,
         mx_zz_outer_prod,
         mx_zz_pinv,
         mx_zz_plus,
         mx_zz_polyval,
         mx_zz_power,
         mx_zz_printCompact,
         mx_zz_quad_form__0,
         mx_zz_quad_form__1,
         mx_zz_rdivide,
         mx_zz_repmat__0,
         mx_zz_repmat__1,
         mx_zz_reshape__0,
         mx_zz_reshape__1,
         mx_zz_sign,
         mx_zz_simplify,
         mx_zz_sin,
         mx_zz_sinh,
         mx_zz_solve,
         mx_zz_sprank,
         mx_zz_sqrt,
         mx_zz_substituteInPlace__0,
         mx_zz_substituteInPlace__1,
         mx_zz_substituteInPlace__2,
         mx_zz_substituteInPlace__3,
         mx_zz_substitute__0,
         mx_zz_substitute__1,
         mx_zz_sumAll,
         mx_zz_sumCols,
         mx_zz_sumRows,
         mx_zz_sum_square,
         mx_zz_tan,
         mx_zz_tangent,
         mx_zz_tanh,
         mx_zz_times,
         mx_zz_trace,
         mx_zz_tril2symm,
         mx_zz_tril__0,
         mx_zz_tril__1,
         mx_zz_triu2symm,
         mx_zz_triu__0,
         mx_zz_triu__1,
         mx_zz_unite,
         mx_zz_vec,
         mx_zz_vecNZ,
         mx_zz_vecNZcat,
         mx_zz_veccat,
         mx_zz_vertcat,
         mx_zz_vertsplit,
       ) 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' -> IO (Ptr MX')
casadi__MX__CONSTRUCTOR__5
  :: Sparsity -> IO MX
casadi__MX__CONSTRUCTOR__5 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__MX__CONSTRUCTOR__5 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
mx__5 :: Sparsity -> 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) -> CInt -> CInt -> IO (Ptr MX')
casadi__MX__CONSTRUCTOR__6
  :: Int -> Int -> IO MX
casadi__MX__CONSTRUCTOR__6 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__MX__CONSTRUCTOR__6 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
mx__6 :: Int -> Int -> 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) -> IO (Ptr MX')
casadi__MX__CONSTRUCTOR__7
  :: IO MX
casadi__MX__CONSTRUCTOR__7  =

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


-- classy wrapper
mx__7 :: IO MX
mx__7 = casadi__MX__CONSTRUCTOR__7


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


-- classy wrapper
mx_T :: MXClass a => a -> IO MX
mx_T x = casadi__MX__T (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____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____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____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____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____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__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__colind" c_casadi__MX__colind
  :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> IO CInt
casadi__MX__colind
  :: MX -> Int -> IO Int
casadi__MX__colind x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__MX__colind errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
mx_colind :: MXClass a => a -> Int -> IO Int
mx_colind x = casadi__MX__colind (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__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__0" c_casadi__MX__enlarge__0
  :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> CInt -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO ()
casadi__MX__enlarge__0
  :: MX -> Int -> Int -> Vector Int -> Vector Int -> IO ()
casadi__MX__enlarge__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__enlarge__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_enlarge__0 :: MXClass a => a -> Int -> Int -> Vector Int -> Vector Int -> IO ()
mx_enlarge__0 x = casadi__MX__enlarge__0 (castMX x)


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


-- classy wrapper
mx_enlarge__1 :: MXClass a => a -> Int -> Int -> Vector Int -> Vector Int -> Bool -> IO ()
mx_enlarge__1 x = casadi__MX__enlarge__1 (castMX x)


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


-- classy wrapper
mx_erase__0 :: MXClass a => a -> Vector Int -> IO ()
mx_erase__0 x = casadi__MX__erase__0 (castMX x)


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


-- classy wrapper
mx_erase__1 :: MXClass a => a -> Vector Int -> Bool -> IO ()
mx_erase__1 x = casadi__MX__erase__1 (castMX x)


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


-- classy wrapper
mx_erase__2 :: MXClass a => a -> Vector Int -> Vector Int -> IO ()
mx_erase__2 x = casadi__MX__erase__2 (castMX x)


-- direct wrapper
foreign import ccall unsafe "casadi__MX__erase__3" c_casadi__MX__erase__3
  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> CInt -> IO ()
casadi__MX__erase__3
  :: MX -> Vector Int -> Vector Int -> Bool -> IO ()
casadi__MX__erase__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__erase__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_erase__3 :: MXClass a => a -> Vector Int -> Vector Int -> Bool -> IO ()
mx_erase__3 x = casadi__MX__erase__3 (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__find__0" c_casadi__MX__find__0
  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr (StdVec CInt))
casadi__MX__find__0
  :: MX -> IO (Vector Int)
casadi__MX__find__0 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__MX__find__0 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
mx_find__0 :: MXClass a => a -> IO (Vector Int)
mx_find__0 x = casadi__MX__find__0 (castMX x)


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


-- classy wrapper
mx_find__1 :: MXClass a => a -> Bool -> IO (Vector Int)
mx_find__1 x = casadi__MX__find__1 (castMX x)


-- direct wrapper
foreign import ccall unsafe "casadi__MX__get__0" c_casadi__MX__get__0
  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> Ptr IMatrix' -> Ptr IMatrix' -> IO ()
casadi__MX__get__0
  :: MX -> MX -> Bool -> IMatrix -> IMatrix -> IO ()
casadi__MX__get__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__get__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_get__0 :: MXClass a => a -> MX -> Bool -> IMatrix -> IMatrix -> IO ()
mx_get__0 x = casadi__MX__get__0 (castMX x)


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


-- classy wrapper
mx_get__1 :: MXClass a => a -> MX -> Bool -> IMatrix -> Slice -> IO ()
mx_get__1 x = casadi__MX__get__1 (castMX x)


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


-- classy wrapper
mx_get__2 :: MXClass a => a -> MX -> Bool -> Slice -> IMatrix -> IO ()
mx_get__2 x = casadi__MX__get__2 (castMX x)


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


-- classy wrapper
mx_get__3 :: MXClass a => a -> MX -> Bool -> Slice -> Slice -> IO ()
mx_get__3 x = casadi__MX__get__3 (castMX x)


-- direct wrapper
foreign import ccall unsafe "casadi__MX__get__4" c_casadi__MX__get__4
  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> Ptr Sparsity' -> IO ()
casadi__MX__get__4
  :: MX -> MX -> Bool -> Sparsity -> IO ()
casadi__MX__get__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__get__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_get__4 :: MXClass a => a -> MX -> Bool -> Sparsity -> IO ()
mx_get__4 x = casadi__MX__get__4 (castMX x)


-- direct wrapper
foreign import ccall unsafe "casadi__MX__get__5" c_casadi__MX__get__5
  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> Ptr IMatrix' -> IO ()
casadi__MX__get__5
  :: MX -> MX -> Bool -> IMatrix -> IO ()
casadi__MX__get__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__get__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_get__5 :: MXClass a => a -> MX -> Bool -> IMatrix -> IO ()
mx_get__5 x = casadi__MX__get__5 (castMX x)


-- direct wrapper
foreign import ccall unsafe "casadi__MX__get__6" c_casadi__MX__get__6
  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> Ptr Slice' -> IO ()
casadi__MX__get__6
  :: MX -> MX -> Bool -> Slice -> IO ()
casadi__MX__get__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__get__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_get__6 :: MXClass a => a -> MX -> Bool -> Slice -> IO ()
mx_get__6 x = casadi__MX__get__6 (castMX x)


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


-- classy wrapper
mx_getColind :: MXClass a => a -> IO (Vector Int)
mx_getColind x = casadi__MX__getColind (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 MX' -> CInt -> Ptr IMatrix' -> IO ()
casadi__MX__getNZ__0
  :: MX -> MX -> Bool -> IMatrix -> IO ()
casadi__MX__getNZ__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__getNZ__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_getNZ__0 :: MXClass a => a -> MX -> Bool -> IMatrix -> IO ()
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 MX' -> CInt -> Ptr Slice' -> IO ()
casadi__MX__getNZ__1
  :: MX -> MX -> Bool -> Slice -> IO ()
casadi__MX__getNZ__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__getNZ__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_getNZ__1 :: MXClass a => a -> MX -> Bool -> Slice -> IO ()
mx_getNZ__1 x = casadi__MX__getNZ__1 (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__getRow" c_casadi__MX__getRow
  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr (StdVec CInt))
casadi__MX__getRow
  :: MX -> IO (Vector Int)
casadi__MX__getRow x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__MX__getRow errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
mx_getRow :: MXClass a => a -> IO (Vector Int)
mx_getRow x = casadi__MX__getRow (castMX x)


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


-- classy wrapper
mx_getSparsity :: MXClass a => a -> IO Sparsity
mx_getSparsity x = casadi__MX__getSparsity (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__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__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__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__isRowVector" c_casadi__MX__isRowVector
  :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt
casadi__MX__isRowVector
  :: MX -> IO Bool
casadi__MX__isRowVector x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__MX__isRowVector errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
mx_isRowVector :: MXClass a => a -> IO Bool
mx_isRowVector x = casadi__MX__isRowVector (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__0" c_casadi__MX__isVector__0
  :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt
casadi__MX__isVector__0
  :: MX -> IO Bool
casadi__MX__isVector__0 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__MX__isVector__0 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
mx_isVector__0 :: MXClass a => a -> IO Bool
mx_isVector__0 x = casadi__MX__isVector__0 (castMX x)


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


-- classy wrapper
mx_isVector__1 :: MXClass a => a -> Bool -> IO Bool
mx_isVector__1 x = casadi__MX__isVector__1 (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__makeDense__0" c_casadi__MX__makeDense__0
  :: Ptr (Ptr StdString) -> Ptr MX' -> IO ()
casadi__MX__makeDense__0
  :: MX -> IO ()
casadi__MX__makeDense__0 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__MX__makeDense__0 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
mx_makeDense__0 :: MXClass a => a -> IO ()
mx_makeDense__0 x = casadi__MX__makeDense__0 (castMX x)


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


-- classy wrapper
mx_makeDense__1 :: MXClass a => a -> MX -> IO ()
mx_makeDense__1 x = casadi__MX__makeDense__1 (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__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__nnz" c_casadi__MX__nnz
  :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt
casadi__MX__nnz
  :: MX -> IO Int
casadi__MX__nnz x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__MX__nnz errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
mx_nnz :: MXClass a => a -> IO Int
mx_nnz x = casadi__MX__nnz (castMX x)


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


-- classy wrapper
mx_numel__0 :: MXClass a => a -> Int -> IO Int
mx_numel__0 x = casadi__MX__numel__0 (castMX x)


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


-- classy wrapper
mx_numel__1 :: MXClass a => a -> IO Int
mx_numel__1 x = casadi__MX__numel__1 (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__operator_minus" c_casadi__MX__operator_minus
  :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
casadi__MX__operator_minus
  :: MX -> IO MX
casadi__MX__operator_minus x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__MX__operator_minus errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
mx_operator_minus :: MXClass a => a -> IO MX
mx_operator_minus x = casadi__MX__operator_minus (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__row" c_casadi__MX__row
  :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> IO CInt
casadi__MX__row
  :: MX -> Int -> IO Int
casadi__MX__row x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__MX__row errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
mx_row :: MXClass a => a -> Int -> IO Int
mx_row x = casadi__MX__row (castMX x)


-- direct wrapper
foreign import ccall unsafe "casadi__MX__set__0" c_casadi__MX__set__0
  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> Ptr IMatrix' -> Ptr IMatrix' -> IO ()
casadi__MX__set__0
  :: MX -> MX -> Bool -> IMatrix -> IMatrix -> IO ()
casadi__MX__set__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__set__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_set__0 :: MXClass a => a -> MX -> Bool -> IMatrix -> IMatrix -> IO ()
mx_set__0 x = casadi__MX__set__0 (castMX x)


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


-- classy wrapper
mx_set__1 :: MXClass a => a -> MX -> Bool -> IMatrix -> Slice -> IO ()
mx_set__1 x = casadi__MX__set__1 (castMX x)


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


-- classy wrapper
mx_set__2 :: MXClass a => a -> MX -> Bool -> Slice -> IMatrix -> IO ()
mx_set__2 x = casadi__MX__set__2 (castMX x)


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


-- classy wrapper
mx_set__3 :: MXClass a => a -> MX -> Bool -> Slice -> Slice -> IO ()
mx_set__3 x = casadi__MX__set__3 (castMX x)


-- direct wrapper
foreign import ccall unsafe "casadi__MX__set__4" c_casadi__MX__set__4
  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> Ptr Sparsity' -> IO ()
casadi__MX__set__4
  :: MX -> MX -> Bool -> Sparsity -> IO ()
casadi__MX__set__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__set__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_set__4 :: MXClass a => a -> MX -> Bool -> Sparsity -> IO ()
mx_set__4 x = casadi__MX__set__4 (castMX x)


-- direct wrapper
foreign import ccall unsafe "casadi__MX__set__5" c_casadi__MX__set__5
  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> Ptr IMatrix' -> IO ()
casadi__MX__set__5
  :: MX -> MX -> Bool -> IMatrix -> IO ()
casadi__MX__set__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__set__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_set__5 :: MXClass a => a -> MX -> Bool -> IMatrix -> IO ()
mx_set__5 x = casadi__MX__set__5 (castMX x)


-- direct wrapper
foreign import ccall unsafe "casadi__MX__set__6" c_casadi__MX__set__6
  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> Ptr Slice' -> IO ()
casadi__MX__set__6
  :: MX -> MX -> Bool -> Slice -> IO ()
casadi__MX__set__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__set__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_set__6 :: MXClass a => a -> MX -> Bool -> Slice -> IO ()
mx_set__6 x = casadi__MX__set__6 (castMX x)


-- 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 MX' -> CInt -> Ptr IMatrix' -> IO ()
casadi__MX__setNZ__0
  :: MX -> MX -> Bool -> IMatrix -> IO ()
casadi__MX__setNZ__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__setNZ__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_setNZ__0 :: MXClass a => a -> MX -> Bool -> IMatrix -> 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 MX' -> CInt -> Ptr Slice' -> IO ()
casadi__MX__setNZ__1
  :: MX -> MX -> Bool -> Slice -> IO ()
casadi__MX__setNZ__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__setNZ__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_setNZ__1 :: MXClass a => a -> MX -> Bool -> Slice -> IO ()
mx_setNZ__1 x = casadi__MX__setNZ__1 (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__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__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) -> Ptr Sparsity' -> Ptr MX' -> IO (Ptr MX')
casadi__MX__sparse__0
  :: Sparsity -> MX -> IO MX
casadi__MX__sparse__0 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__MX__sparse__0 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
mx_sparse__0 :: Sparsity -> MX -> 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) -> IO (Ptr MX')
casadi__MX__sparse__1
  :: IO MX
casadi__MX__sparse__1  =

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


-- classy wrapper
mx_sparse__1 :: 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 -> IO (Ptr MX')
casadi__MX__sparse__2
  :: Int -> IO MX
casadi__MX__sparse__2 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__MX__sparse__2 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


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


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


-- classy wrapper
mx_sparse__3 :: Int -> Int -> IO MX
mx_sparse__3 = casadi__MX__sparse__3


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


-- classy wrapper
mx_sparsity :: MXClass a => a -> IO Sparsity
mx_sparsity x = casadi__MX__sparsity (castMX x)


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


-- classy wrapper
mx_sparsityRef :: MXClass a => a -> IO Sparsity
mx_sparsityRef x = casadi__MX__sparsityRef (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__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


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


-- classy wrapper
mx_zz_abs :: MXClass a => a -> IO MX
mx_zz_abs x = casadi__MX__zz_abs (castMX x)


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


-- classy wrapper
mx_zz_acos :: MXClass a => a -> IO MX
mx_zz_acos x = casadi__MX__zz_acos (castMX x)


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


-- classy wrapper
mx_zz_acosh :: MXClass a => a -> IO MX
mx_zz_acosh x = casadi__MX__zz_acosh (castMX x)


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


-- classy wrapper
mx_zz_and :: MXClass a => a -> MX -> IO MX
mx_zz_and x = casadi__MX__zz_and (castMX x)


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


-- classy wrapper
mx_zz_asin :: MXClass a => a -> IO MX
mx_zz_asin x = casadi__MX__zz_asin (castMX x)


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


-- classy wrapper
mx_zz_asinh :: MXClass a => a -> IO MX
mx_zz_asinh x = casadi__MX__zz_asinh (castMX x)


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


-- classy wrapper
mx_zz_atan :: MXClass a => a -> IO MX
mx_zz_atan x = casadi__MX__zz_atan (castMX x)


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


-- classy wrapper
mx_zz_atan2 :: MXClass a => a -> MX -> IO MX
mx_zz_atan2 x = casadi__MX__zz_atan2 (castMX x)


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


-- classy wrapper
mx_zz_atanh :: MXClass a => a -> IO MX
mx_zz_atanh x = casadi__MX__zz_atanh (castMX x)


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


-- classy wrapper
mx_zz_blockcat :: Vector (Vector MX) -> IO MX
mx_zz_blockcat = casadi__MX__zz_blockcat


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


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


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


-- classy wrapper
mx_zz_ceil :: MXClass a => a -> IO MX
mx_zz_ceil x = casadi__MX__zz_ceil (castMX x)


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


-- classy wrapper
mx_zz_cos :: MXClass a => a -> IO MX
mx_zz_cos x = casadi__MX__zz_cos (castMX x)


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


-- classy wrapper
mx_zz_cosh :: MXClass a => a -> IO MX
mx_zz_cosh x = casadi__MX__zz_cosh (castMX x)


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


-- classy wrapper
mx_zz_countNodes :: MXClass a => a -> IO Int
mx_zz_countNodes x = casadi__MX__zz_countNodes (castMX x)


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


-- classy wrapper
mx_zz_createParent__0 :: Vector MX -> Vector MX -> IO MX
mx_zz_createParent__0 = casadi__MX__zz_createParent__0


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


-- classy wrapper
mx_zz_createParent__1 :: Vector Sparsity -> Vector MX -> IO MX
mx_zz_createParent__1 = casadi__MX__zz_createParent__1


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


-- classy wrapper
mx_zz_createParent__2 :: Vector MX -> IO MX
mx_zz_createParent__2 = casadi__MX__zz_createParent__2


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


-- classy wrapper
mx_zz_cross__0 :: MXClass a => a -> MX -> IO MX
mx_zz_cross__0 x = casadi__MX__zz_cross__0 (castMX x)


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


-- classy wrapper
mx_zz_cross__1 :: MXClass a => a -> MX -> Int -> IO MX
mx_zz_cross__1 x = casadi__MX__zz_cross__1 (castMX x)


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


-- classy wrapper
mx_zz_densify :: MXClass a => a -> IO MX
mx_zz_densify x = casadi__MX__zz_densify (castMX x)


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


-- classy wrapper
mx_zz_dependsOn :: MXClass a => a -> Vector MX -> IO Bool
mx_zz_dependsOn x = casadi__MX__zz_dependsOn (castMX x)


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


-- classy wrapper
mx_zz_det :: MXClass a => a -> IO MX
mx_zz_det x = casadi__MX__zz_det (castMX x)


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


-- classy wrapper
mx_zz_diag :: MXClass a => a -> IO MX
mx_zz_diag x = casadi__MX__zz_diag (castMX x)


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


-- classy wrapper
mx_zz_diagcat :: Vector MX -> IO MX
mx_zz_diagcat = casadi__MX__zz_diagcat


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


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


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


-- classy wrapper
mx_zz_eq :: MXClass a => a -> MX -> IO MX
mx_zz_eq x = casadi__MX__zz_eq (castMX x)


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


-- classy wrapper
mx_zz_erf :: MXClass a => a -> IO MX
mx_zz_erf x = casadi__MX__zz_erf (castMX x)


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


-- classy wrapper
mx_zz_erfinv :: MXClass a => a -> IO MX
mx_zz_erfinv x = casadi__MX__zz_erfinv (castMX x)


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


-- classy wrapper
mx_zz_exp :: MXClass a => a -> IO MX
mx_zz_exp x = casadi__MX__zz_exp (castMX x)


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


-- classy wrapper
mx_zz_extractShared__0 :: Vector MX -> Vector MX -> Vector MX -> IO ()
mx_zz_extractShared__0 = casadi__MX__zz_extractShared__0


-- direct wrapper
foreign import ccall unsafe "casadi__MX__zz_extractShared__1" c_casadi__MX__zz_extractShared__1
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> IO ()
casadi__MX__zz_extractShared__1
  :: Vector MX -> Vector MX -> Vector MX -> String -> IO ()
casadi__MX__zz_extractShared__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__zz_extractShared__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_zz_extractShared__1 :: Vector MX -> Vector MX -> Vector MX -> String -> IO ()
mx_zz_extractShared__1 = casadi__MX__zz_extractShared__1


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


-- classy wrapper
mx_zz_extractShared__2 :: Vector MX -> Vector MX -> Vector MX -> String -> String -> IO ()
mx_zz_extractShared__2 = casadi__MX__zz_extractShared__2


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


-- classy wrapper
mx_zz_floor :: MXClass a => a -> IO MX
mx_zz_floor x = casadi__MX__zz_floor (castMX x)


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


-- classy wrapper
mx_zz_ge :: MXClass a => a -> MX -> IO MX
mx_zz_ge x = casadi__MX__zz_ge (castMX x)


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


-- classy wrapper
mx_zz_getOperatorRepresentation :: MXClass a => a -> Vector String -> IO String
mx_zz_getOperatorRepresentation x = casadi__MX__zz_getOperatorRepresentation (castMX x)


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


-- classy wrapper
mx_zz_getSymbols__0 :: Vector MX -> IO (Vector MX)
mx_zz_getSymbols__0 = casadi__MX__zz_getSymbols__0


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


-- classy wrapper
mx_zz_getSymbols__1 :: MXClass a => a -> IO (Vector MX)
mx_zz_getSymbols__1 x = casadi__MX__zz_getSymbols__1 (castMX x)


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


-- classy wrapper
mx_zz_gradient :: MXClass a => a -> MX -> IO MX
mx_zz_gradient x = casadi__MX__zz_gradient (castMX x)


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


-- classy wrapper
mx_zz_graph_substitute__0 :: Vector MX -> Vector MX -> Vector MX -> IO (Vector MX)
mx_zz_graph_substitute__0 = casadi__MX__zz_graph_substitute__0


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


-- classy wrapper
mx_zz_graph_substitute__1 :: MXClass a => a -> Vector MX -> Vector MX -> IO MX
mx_zz_graph_substitute__1 x = casadi__MX__zz_graph_substitute__1 (castMX x)


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


-- classy wrapper
mx_zz_gt :: MXClass a => a -> MX -> IO MX
mx_zz_gt x = casadi__MX__zz_gt (castMX x)


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


-- classy wrapper
mx_zz_horzcat :: Vector MX -> IO MX
mx_zz_horzcat = casadi__MX__zz_horzcat


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


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


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


-- classy wrapper
mx_zz_if_else :: MXClass a => a -> MX -> MX -> IO MX
mx_zz_if_else x = casadi__MX__zz_if_else (castMX x)


-- direct wrapper
foreign import ccall unsafe "casadi__MX__zz_if_else_zero" c_casadi__MX__zz_if_else_zero
  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
casadi__MX__zz_if_else_zero
  :: MX -> MX -> IO MX
casadi__MX__zz_if_else_zero x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__MX__zz_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_zz_if_else_zero :: MXClass a => a -> MX -> IO MX
mx_zz_if_else_zero x = casadi__MX__zz_if_else_zero (castMX x)


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


-- classy wrapper
mx_zz_inner_prod :: MXClass a => a -> MX -> IO MX
mx_zz_inner_prod x = casadi__MX__zz_inner_prod (castMX x)


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


-- classy wrapper
mx_zz_inv :: MXClass a => a -> IO MX
mx_zz_inv x = casadi__MX__zz_inv (castMX x)


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


-- classy wrapper
mx_zz_isEqual__0 :: MXClass a => a -> MX -> IO Bool
mx_zz_isEqual__0 x = casadi__MX__zz_isEqual__0 (castMX x)


-- direct wrapper
foreign import ccall unsafe "casadi__MX__zz_isEqual__1" c_casadi__MX__zz_isEqual__1
  :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> IO CInt
casadi__MX__zz_isEqual__1
  :: MX -> MX -> Int -> IO Bool
casadi__MX__zz_isEqual__1 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__MX__zz_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_zz_isEqual__1 :: MXClass a => a -> MX -> Int -> IO Bool
mx_zz_isEqual__1 x = casadi__MX__zz_isEqual__1 (castMX x)


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


-- classy wrapper
mx_zz_jacobian :: MXClass a => a -> MX -> IO MX
mx_zz_jacobian x = casadi__MX__zz_jacobian (castMX x)


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


-- classy wrapper
mx_zz_kron :: MXClass a => a -> MX -> IO MX
mx_zz_kron x = casadi__MX__zz_kron (castMX x)


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


-- classy wrapper
mx_zz_le :: MXClass a => a -> MX -> IO MX
mx_zz_le x = casadi__MX__zz_le (castMX x)


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


-- classy wrapper
mx_zz_linspace :: MXClass a => a -> MX -> Int -> IO MX
mx_zz_linspace x = casadi__MX__zz_linspace (castMX x)


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


-- classy wrapper
mx_zz_log :: MXClass a => a -> IO MX
mx_zz_log x = casadi__MX__zz_log (castMX x)


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


-- classy wrapper
mx_zz_log10 :: MXClass a => a -> IO MX
mx_zz_log10 x = casadi__MX__zz_log10 (castMX x)


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


-- classy wrapper
mx_zz_lt :: MXClass a => a -> MX -> IO MX
mx_zz_lt x = casadi__MX__zz_lt (castMX x)


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


-- classy wrapper
mx_zz_matrix_expand__0 :: Vector MX -> IO (Vector MX)
mx_zz_matrix_expand__0 = casadi__MX__zz_matrix_expand__0


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


-- classy wrapper
mx_zz_matrix_expand__1 :: Vector MX -> Vector MX -> IO (Vector MX)
mx_zz_matrix_expand__1 = casadi__MX__zz_matrix_expand__1


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


-- classy wrapper
mx_zz_matrix_expand__2 :: MX -> IO MX
mx_zz_matrix_expand__2 = casadi__MX__zz_matrix_expand__2


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


-- classy wrapper
mx_zz_matrix_expand__3 :: MX -> Vector MX -> IO MX
mx_zz_matrix_expand__3 = casadi__MX__zz_matrix_expand__3


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


-- classy wrapper
mx_zz_max :: MXClass a => a -> MX -> IO MX
mx_zz_max x = casadi__MX__zz_max (castMX x)


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


-- classy wrapper
mx_zz_min :: MXClass a => a -> MX -> IO MX
mx_zz_min x = casadi__MX__zz_min (castMX x)


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


-- classy wrapper
mx_zz_minus :: MXClass a => a -> MX -> IO MX
mx_zz_minus x = casadi__MX__zz_minus (castMX x)


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


-- classy wrapper
mx_zz_mod :: MXClass a => a -> MX -> IO MX
mx_zz_mod x = casadi__MX__zz_mod (castMX x)


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


-- classy wrapper
mx_zz_mpower :: MXClass a => a -> MX -> IO MX
mx_zz_mpower x = casadi__MX__zz_mpower (castMX x)


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


-- classy wrapper
mx_zz_mtimes__0 :: MXClass a => a -> MX -> MX -> IO MX
mx_zz_mtimes__0 x = casadi__MX__zz_mtimes__0 (castMX x)


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


-- classy wrapper
mx_zz_mtimes__1 :: MXClass a => a -> MX -> IO MX
mx_zz_mtimes__1 x = casadi__MX__zz_mtimes__1 (castMX x)


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


-- classy wrapper
mx_zz_ne :: MXClass a => a -> MX -> IO MX
mx_zz_ne x = casadi__MX__zz_ne (castMX x)


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


-- classy wrapper
mx_zz_norm_0_mul :: MXClass a => a -> MX -> IO Int
mx_zz_norm_0_mul x = casadi__MX__zz_norm_0_mul (castMX x)


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


-- classy wrapper
mx_zz_norm_1 :: MXClass a => a -> IO MX
mx_zz_norm_1 x = casadi__MX__zz_norm_1 (castMX x)


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


-- classy wrapper
mx_zz_norm_2 :: MXClass a => a -> IO MX
mx_zz_norm_2 x = casadi__MX__zz_norm_2 (castMX x)


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


-- classy wrapper
mx_zz_norm_F :: MXClass a => a -> IO MX
mx_zz_norm_F x = casadi__MX__zz_norm_F (castMX x)


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


-- classy wrapper
mx_zz_norm_inf :: MXClass a => a -> IO MX
mx_zz_norm_inf x = casadi__MX__zz_norm_inf (castMX x)


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


-- classy wrapper
mx_zz_not :: MXClass a => a -> IO MX
mx_zz_not x = casadi__MX__zz_not (castMX x)


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


-- classy wrapper
mx_zz_nullspace :: MXClass a => a -> IO MX
mx_zz_nullspace x = casadi__MX__zz_nullspace (castMX x)


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


-- classy wrapper
mx_zz_or :: MXClass a => a -> MX -> IO MX
mx_zz_or x = casadi__MX__zz_or (castMX x)


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


-- classy wrapper
mx_zz_outer_prod :: MXClass a => a -> MX -> IO MX
mx_zz_outer_prod x = casadi__MX__zz_outer_prod (castMX x)


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


-- classy wrapper
mx_zz_pinv :: MXClass a => a -> String -> IO MX
mx_zz_pinv x = casadi__MX__zz_pinv (castMX x)


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


-- classy wrapper
mx_zz_plus :: MXClass a => a -> MX -> IO MX
mx_zz_plus x = casadi__MX__zz_plus (castMX x)


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


-- classy wrapper
mx_zz_polyval :: MXClass a => a -> MX -> IO MX
mx_zz_polyval x = casadi__MX__zz_polyval (castMX x)


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


-- classy wrapper
mx_zz_power :: MXClass a => a -> MX -> IO MX
mx_zz_power x = casadi__MX__zz_power (castMX x)


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


-- classy wrapper
mx_zz_printCompact :: MXClass a => a -> IO ()
mx_zz_printCompact x = casadi__MX__zz_printCompact (castMX x)


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


-- classy wrapper
mx_zz_quad_form__0 :: MXClass a => a -> IO MX
mx_zz_quad_form__0 x = casadi__MX__zz_quad_form__0 (castMX x)


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


-- classy wrapper
mx_zz_quad_form__1 :: MXClass a => a -> MX -> IO MX
mx_zz_quad_form__1 x = casadi__MX__zz_quad_form__1 (castMX x)


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


-- classy wrapper
mx_zz_rdivide :: MXClass a => a -> MX -> IO MX
mx_zz_rdivide x = casadi__MX__zz_rdivide (castMX x)


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


-- classy wrapper
mx_zz_repmat__0 :: MXClass a => a -> Int -> IO MX
mx_zz_repmat__0 x = casadi__MX__zz_repmat__0 (castMX x)


-- direct wrapper
foreign import ccall unsafe "casadi__MX__zz_repmat__1" c_casadi__MX__zz_repmat__1
  :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> CInt -> IO (Ptr MX')
casadi__MX__zz_repmat__1
  :: MX -> Int -> Int -> IO MX
casadi__MX__zz_repmat__1 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__MX__zz_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_zz_repmat__1 :: MXClass a => a -> Int -> Int -> IO MX
mx_zz_repmat__1 x = casadi__MX__zz_repmat__1 (castMX x)


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


-- classy wrapper
mx_zz_reshape__0 :: MXClass a => a -> Sparsity -> IO MX
mx_zz_reshape__0 x = casadi__MX__zz_reshape__0 (castMX x)


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


-- classy wrapper
mx_zz_reshape__1 :: MXClass a => a -> Int -> Int -> IO MX
mx_zz_reshape__1 x = casadi__MX__zz_reshape__1 (castMX x)


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


-- classy wrapper
mx_zz_sign :: MXClass a => a -> IO MX
mx_zz_sign x = casadi__MX__zz_sign (castMX x)


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


-- classy wrapper
mx_zz_simplify :: MXClass a => a -> IO MX
mx_zz_simplify x = casadi__MX__zz_simplify (castMX x)


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


-- classy wrapper
mx_zz_sin :: MXClass a => a -> IO MX
mx_zz_sin x = casadi__MX__zz_sin (castMX x)


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


-- classy wrapper
mx_zz_sinh :: MXClass a => a -> IO MX
mx_zz_sinh x = casadi__MX__zz_sinh (castMX x)


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


-- classy wrapper
mx_zz_solve :: MXClass a => a -> MX -> String -> IO MX
mx_zz_solve x = casadi__MX__zz_solve (castMX x)


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


-- classy wrapper
mx_zz_sprank :: MXClass a => a -> IO Int
mx_zz_sprank x = casadi__MX__zz_sprank (castMX x)


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


-- classy wrapper
mx_zz_sqrt :: MXClass a => a -> IO MX
mx_zz_sqrt x = casadi__MX__zz_sqrt (castMX x)


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


-- classy wrapper
mx_zz_substitute__0 :: Vector MX -> Vector MX -> Vector MX -> IO (Vector MX)
mx_zz_substitute__0 = casadi__MX__zz_substitute__0


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


-- classy wrapper
mx_zz_substitute__1 :: MXClass a => a -> MX -> MX -> IO MX
mx_zz_substitute__1 x = casadi__MX__zz_substitute__1 (castMX x)


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


-- classy wrapper
mx_zz_substituteInPlace__0 :: Vector MX -> Vector MX -> Vector MX -> IO ()
mx_zz_substituteInPlace__0 = casadi__MX__zz_substituteInPlace__0


-- direct wrapper
foreign import ccall unsafe "casadi__MX__zz_substituteInPlace__1" c_casadi__MX__zz_substituteInPlace__1
  :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> CInt -> IO ()
casadi__MX__zz_substituteInPlace__1
  :: Vector MX -> Vector MX -> Vector MX -> Bool -> IO ()
casadi__MX__zz_substituteInPlace__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__zz_substituteInPlace__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_zz_substituteInPlace__1 :: Vector MX -> Vector MX -> Vector MX -> Bool -> IO ()
mx_zz_substituteInPlace__1 = casadi__MX__zz_substituteInPlace__1


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


-- classy wrapper
mx_zz_substituteInPlace__2 :: Vector MX -> Vector MX -> IO ()
mx_zz_substituteInPlace__2 = casadi__MX__zz_substituteInPlace__2


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


-- classy wrapper
mx_zz_substituteInPlace__3 :: Vector MX -> Vector MX -> Bool -> IO ()
mx_zz_substituteInPlace__3 = casadi__MX__zz_substituteInPlace__3


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


-- classy wrapper
mx_zz_sumAll :: MXClass a => a -> IO MX
mx_zz_sumAll x = casadi__MX__zz_sumAll (castMX x)


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


-- classy wrapper
mx_zz_sumCols :: MXClass a => a -> IO MX
mx_zz_sumCols x = casadi__MX__zz_sumCols (castMX x)


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


-- classy wrapper
mx_zz_sumRows :: MXClass a => a -> IO MX
mx_zz_sumRows x = casadi__MX__zz_sumRows (castMX x)


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


-- classy wrapper
mx_zz_sum_square :: MXClass a => a -> IO MX
mx_zz_sum_square x = casadi__MX__zz_sum_square (castMX x)


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


-- classy wrapper
mx_zz_tan :: MXClass a => a -> IO MX
mx_zz_tan x = casadi__MX__zz_tan (castMX x)


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


-- classy wrapper
mx_zz_tangent :: MXClass a => a -> MX -> IO MX
mx_zz_tangent x = casadi__MX__zz_tangent (castMX x)


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


-- classy wrapper
mx_zz_tanh :: MXClass a => a -> IO MX
mx_zz_tanh x = casadi__MX__zz_tanh (castMX x)


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


-- classy wrapper
mx_zz_times :: MXClass a => a -> MX -> IO MX
mx_zz_times x = casadi__MX__zz_times (castMX x)


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


-- classy wrapper
mx_zz_trace :: MXClass a => a -> IO MX
mx_zz_trace x = casadi__MX__zz_trace (castMX x)


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


-- classy wrapper
mx_zz_tril__0 :: MXClass a => a -> IO MX
mx_zz_tril__0 x = casadi__MX__zz_tril__0 (castMX x)


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


-- classy wrapper
mx_zz_tril__1 :: MXClass a => a -> Bool -> IO MX
mx_zz_tril__1 x = casadi__MX__zz_tril__1 (castMX x)


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


-- classy wrapper
mx_zz_tril2symm :: MXClass a => a -> IO MX
mx_zz_tril2symm x = casadi__MX__zz_tril2symm (castMX x)


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


-- classy wrapper
mx_zz_triu__0 :: MXClass a => a -> IO MX
mx_zz_triu__0 x = casadi__MX__zz_triu__0 (castMX x)


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


-- classy wrapper
mx_zz_triu__1 :: MXClass a => a -> Bool -> IO MX
mx_zz_triu__1 x = casadi__MX__zz_triu__1 (castMX x)


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


-- classy wrapper
mx_zz_triu2symm :: MXClass a => a -> IO MX
mx_zz_triu2symm x = casadi__MX__zz_triu2symm (castMX x)


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


-- classy wrapper
mx_zz_unite :: MXClass a => a -> MX -> IO MX
mx_zz_unite x = casadi__MX__zz_unite (castMX x)


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


-- classy wrapper
mx_zz_vec :: MXClass a => a -> IO MX
mx_zz_vec x = casadi__MX__zz_vec (castMX x)


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


-- classy wrapper
mx_zz_vecNZ :: MXClass a => a -> IO MX
mx_zz_vecNZ x = casadi__MX__zz_vecNZ (castMX x)


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


-- classy wrapper
mx_zz_vecNZcat :: Vector MX -> IO MX
mx_zz_vecNZcat = casadi__MX__zz_vecNZcat


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


-- classy wrapper
mx_zz_veccat :: Vector MX -> IO MX
mx_zz_veccat = casadi__MX__zz_veccat


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


-- classy wrapper
mx_zz_vertcat :: Vector MX -> IO MX
mx_zz_vertcat = casadi__MX__zz_vertcat


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


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