casadi-bindings-core-1.9.0.5: Casadi/Core/Classes/IMatrix.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.IMatrix
       (
         IMatrix,
         IMatrixClass(..),
         imatrix__0,
         imatrix__1,
         imatrix__2,
         imatrix__3,
         imatrix__4,
         imatrix__5,
         imatrix__6,
         imatrix__7,
         imatrix__8,
         imatrix___add__,
         imatrix___constpow__,
         imatrix___copysign__,
         imatrix___div__,
         imatrix___eq__,
         imatrix___ge____0,
         imatrix___ge____1,
         imatrix___gt____0,
         imatrix___gt____1,
         imatrix___le__,
         imatrix___lt__,
         imatrix___mldivide__,
         imatrix___mpower__,
         imatrix___mrdivide__,
         imatrix___mul__,
         imatrix___ne__,
         imatrix___nonzero__,
         imatrix___pow__,
         imatrix___radd__,
         imatrix___rdiv__,
         imatrix___req__,
         imatrix___rge__,
         imatrix___rgt__,
         imatrix___rle__,
         imatrix___rlt__,
         imatrix___rmul__,
         imatrix___rne__,
         imatrix___rsub__,
         imatrix___rtruediv__,
         imatrix___sub__,
         imatrix___truediv____0,
         imatrix___truediv____1,
         imatrix_append,
         imatrix_appendColumns,
         imatrix_arccos,
         imatrix_arccosh,
         imatrix_arcsin,
         imatrix_arcsinh,
         imatrix_arctan,
         imatrix_arctan2,
         imatrix_arctanh,
         imatrix_at,
         imatrix_binary,
         imatrix_ceil,
         imatrix_className,
         imatrix_clear,
         imatrix_colind__0,
         imatrix_colind__1,
         imatrix_cos,
         imatrix_cosh,
         imatrix_data__0,
         imatrix_data__1,
         imatrix_densify__0,
         imatrix_densify__1,
         imatrix_dimString,
         imatrix_elem__0,
         imatrix_elem__1,
         imatrix_enlarge,
         imatrix_erase,
         imatrix_erf,
         imatrix_erfinv,
         imatrix_exp,
         imatrix_eye,
         imatrix_fabs,
         imatrix_floor,
         imatrix_fmax,
         imatrix_fmin,
         imatrix_fmod,
         imatrix_getElement__0,
         imatrix_getElement__1,
         imatrix_getEqualityCheckingDepth,
         imatrix_getMaxNumCallsInPrint,
         imatrix_getNZ__0,
         imatrix_getNZ__1,
         imatrix_getNZ__2,
         imatrix_getNZ__3,
         imatrix_getName,
         imatrix_getValue,
         imatrix_get__0,
         imatrix_get__1,
         imatrix_get__2,
         imatrix_get__3,
         imatrix_get__4,
         imatrix_get__5,
         imatrix_hasNZ,
         imatrix_hasNonStructuralZeros,
         imatrix_if_else_zero,
         imatrix_indexed__0,
         imatrix_indexed__1,
         imatrix_indexed__2,
         imatrix_indexed__3,
         imatrix_indexed__4,
         imatrix_indexed__5,
         imatrix_indexed_assignment__0,
         imatrix_indexed_assignment__1,
         imatrix_indexed_assignment__2,
         imatrix_indexed_assignment__3,
         imatrix_indexed_assignment__4,
         imatrix_indexed_assignment__5,
         imatrix_indexed_one_based__0,
         imatrix_indexed_one_based__1,
         imatrix_indexed_one_based__2,
         imatrix_indexed_one_based_assignment__0,
         imatrix_indexed_one_based_assignment__1,
         imatrix_indexed_one_based_assignment__2,
         imatrix_indexed_zero_based__0,
         imatrix_indexed_zero_based__1,
         imatrix_indexed_zero_based__2,
         imatrix_indexed_zero_based_assignment__0,
         imatrix_indexed_zero_based_assignment__1,
         imatrix_indexed_zero_based_assignment__2,
         imatrix_inf__0,
         imatrix_inf__1,
         imatrix_inf__2,
         imatrix_inf__3,
         imatrix_isConstant,
         imatrix_isDense,
         imatrix_isEmpty__0,
         imatrix_isEmpty__1,
         imatrix_isEqual,
         imatrix_isIdentity,
         imatrix_isInteger,
         imatrix_isMinusOne,
         imatrix_isOne,
         imatrix_isRegular,
         imatrix_isScalar__0,
         imatrix_isScalar__1,
         imatrix_isSmooth,
         imatrix_isSquare,
         imatrix_isSymbolic,
         imatrix_isSymbolicSparse,
         imatrix_isTril,
         imatrix_isTriu,
         imatrix_isVector,
         imatrix_isZero,
         imatrix_log,
         imatrix_log10,
         imatrix_logic_and,
         imatrix_logic_not,
         imatrix_logic_or,
         imatrix_matrix_matrix,
         imatrix_matrix_scalar,
         imatrix_mul__0,
         imatrix_mul__1,
         imatrix_mul_full__0,
         imatrix_mul_full__1,
         imatrix_mul_no_alloc_nn__0,
         imatrix_mul_no_alloc_nn__1,
         imatrix_mul_no_alloc_nt,
         imatrix_mul_no_alloc_tn__0,
         imatrix_mul_no_alloc_tn__1,
         imatrix_mul_smart,
         imatrix_nan__0,
         imatrix_nan__1,
         imatrix_nan__2,
         imatrix_nan__3,
         imatrix_numel,
         imatrix_nz_indexed,
         imatrix_nz_indexed_assignment,
         imatrix_nz_indexed_one_based__0,
         imatrix_nz_indexed_one_based__1,
         imatrix_nz_indexed_one_based_assignment__0,
         imatrix_nz_indexed_one_based_assignment__1,
         imatrix_nz_indexed_zero_based__0,
         imatrix_nz_indexed_zero_based__1,
         imatrix_nz_indexed_zero_based_assignment__0,
         imatrix_nz_indexed_zero_based_assignment__1,
         imatrix_ones__0,
         imatrix_ones__1,
         imatrix_ones__2,
         imatrix_ones__3,
         imatrix_printDense,
         imatrix_printScalar,
         imatrix_printSparse,
         imatrix_printVector,
         imatrix_printme,
         imatrix_quad_form,
         imatrix_remove,
         imatrix_repmat__0,
         imatrix_repmat__1,
         imatrix_repmat__2,
         imatrix_repmat__3,
         imatrix_reserve__0,
         imatrix_reserve__1,
         imatrix_resize,
         imatrix_row__0,
         imatrix_row__1,
         imatrix_sanityCheck__0,
         imatrix_sanityCheck__1,
         imatrix_scalar_matrix,
         imatrix_setAll,
         imatrix_setEqualityCheckingDepth__0,
         imatrix_setEqualityCheckingDepth__1,
         imatrix_setMaxNumCallsInPrint__0,
         imatrix_setMaxNumCallsInPrint__1,
         imatrix_setNZ__0,
         imatrix_setNZ__1,
         imatrix_setNZ__2,
         imatrix_setNZ__3,
         imatrix_setPrecision,
         imatrix_setScientific,
         imatrix_setSparse__0,
         imatrix_setSparse__1,
         imatrix_setSub__0,
         imatrix_setSub__1,
         imatrix_setSub__10,
         imatrix_setSub__11,
         imatrix_setSub__12,
         imatrix_setSub__13,
         imatrix_setSub__14,
         imatrix_setSub__15,
         imatrix_setSub__16,
         imatrix_setSub__2,
         imatrix_setSub__3,
         imatrix_setSub__4,
         imatrix_setSub__5,
         imatrix_setSub__6,
         imatrix_setSub__7,
         imatrix_setSub__8,
         imatrix_setSub__9,
         imatrix_setWidth,
         imatrix_setZero,
         imatrix_set__0,
         imatrix_set__1,
         imatrix_set__2,
         imatrix_set__3,
         imatrix_set__4,
         imatrix_set__5,
         imatrix_sign,
         imatrix_sin,
         imatrix_sinh,
         imatrix_size1,
         imatrix_size2,
         imatrix_sizeD,
         imatrix_sizeL,
         imatrix_sizeU,
         imatrix_size__0,
         imatrix_size__1,
         imatrix_sparse__0,
         imatrix_sparse__1,
         imatrix_sparse__2,
         imatrix_sparsify__0,
         imatrix_sparsify__1,
         imatrix_sparsityRef__0,
         imatrix_sparsityRef__1,
         imatrix_sparsity__0,
         imatrix_sparsity__1,
         imatrix_sqrt,
         imatrix_sub__0,
         imatrix_sub__1,
         imatrix_sub__10,
         imatrix_sub__11,
         imatrix_sub__12,
         imatrix_sub__13,
         imatrix_sub__14,
         imatrix_sub__15,
         imatrix_sub__16,
         imatrix_sub__17,
         imatrix_sub__2,
         imatrix_sub__3,
         imatrix_sub__4,
         imatrix_sub__5,
         imatrix_sub__6,
         imatrix_sub__7,
         imatrix_sub__8,
         imatrix_sub__9,
         imatrix_sym__0,
         imatrix_sym__1,
         imatrix_sym__2,
         imatrix_sym__3,
         imatrix_sym__4,
         imatrix_sym__5,
         imatrix_sym__6,
         imatrix_sym__7,
         imatrix_tan,
         imatrix_tanh,
         imatrix_toScalar,
         imatrix_trans,
         imatrix_triplet__0,
         imatrix_triplet__1,
         imatrix_unary,
         imatrix_zeros__0,
         imatrix_zeros__1,
         imatrix_zeros__2,
         imatrix_zeros__3,
       ) where


import Prelude hiding ( Functor )

import Data.Vector ( Vector )
import Foreign.C.Types
import Foreign.Marshal ( new, free )
import Foreign.Storable ( peek )
import Foreign.Ptr ( Ptr, nullPtr )
import Foreign.ForeignPtr ( newForeignPtr )
import System.IO.Unsafe ( unsafePerformIO ) -- for show instances

import Casadi.Core.Classes.PrintableObject
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

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


-- classy wrapper
imatrix__0 :: Vector Int -> Int -> Int -> IO IMatrix
imatrix__0 = casadi__IMatrix__CONSTRUCTOR__0


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


-- classy wrapper
imatrix__1 :: Vector Int -> IO IMatrix
imatrix__1 = casadi__IMatrix__CONSTRUCTOR__1


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


-- classy wrapper
imatrix__2 :: Double -> IO IMatrix
imatrix__2 = casadi__IMatrix__CONSTRUCTOR__2


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


-- classy wrapper
imatrix__3 :: Sparsity -> Vector Int -> IO IMatrix
imatrix__3 = casadi__IMatrix__CONSTRUCTOR__3


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


-- classy wrapper
imatrix__4 :: Sparsity -> IO IMatrix
imatrix__4 = casadi__IMatrix__CONSTRUCTOR__4


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


-- classy wrapper
imatrix__5 :: Sparsity -> Int -> IO IMatrix
imatrix__5 = casadi__IMatrix__CONSTRUCTOR__5


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


-- classy wrapper
imatrix__6 :: Vector (Vector Int) -> IO IMatrix
imatrix__6 = casadi__IMatrix__CONSTRUCTOR__6


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


-- classy wrapper
imatrix__7 :: IMatrix -> IO IMatrix
imatrix__7 = casadi__IMatrix__CONSTRUCTOR__7


-- direct wrapper
foreign import ccall unsafe "casadi__IMatrix__CONSTRUCTOR__8" c_casadi__IMatrix__CONSTRUCTOR__8
  :: Ptr (Ptr StdString) -> IO (Ptr IMatrix')
casadi__IMatrix__CONSTRUCTOR__8
  :: IO IMatrix
casadi__IMatrix__CONSTRUCTOR__8  =

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


-- classy wrapper
imatrix__8 :: IO IMatrix
imatrix__8 = casadi__IMatrix__CONSTRUCTOR__8


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


-- classy wrapper
imatrix___add__ :: IMatrixClass a => a -> IMatrix -> IO IMatrix
imatrix___add__ x = casadi__IMatrix____add__ (castIMatrix x)


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


-- classy wrapper
imatrix___constpow__ :: IMatrixClass a => a -> IMatrix -> IO IMatrix
imatrix___constpow__ x = casadi__IMatrix____constpow__ (castIMatrix x)


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


-- classy wrapper
imatrix___copysign__ :: IMatrixClass a => a -> IMatrix -> IO IMatrix
imatrix___copysign__ x = casadi__IMatrix____copysign__ (castIMatrix x)


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


-- classy wrapper
imatrix___div__ :: IMatrixClass a => a -> IMatrix -> IO IMatrix
imatrix___div__ x = casadi__IMatrix____div__ (castIMatrix x)


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


-- classy wrapper
imatrix___eq__ :: IMatrixClass a => a -> IMatrix -> IO IMatrix
imatrix___eq__ x = casadi__IMatrix____eq__ (castIMatrix x)


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


-- classy wrapper
imatrix___ge____0 :: IMatrixClass a => a -> IMatrix -> IO IMatrix
imatrix___ge____0 x = casadi__IMatrix____ge____0 (castIMatrix x)


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


-- classy wrapper
imatrix___ge____1 :: IMatrixClass a => a -> IMatrix -> IO IMatrix
imatrix___ge____1 x = casadi__IMatrix____ge____1 (castIMatrix x)


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


-- classy wrapper
imatrix___gt____0 :: IMatrixClass a => a -> IMatrix -> IO IMatrix
imatrix___gt____0 x = casadi__IMatrix____gt____0 (castIMatrix x)


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


-- classy wrapper
imatrix___gt____1 :: IMatrixClass a => a -> IMatrix -> IO IMatrix
imatrix___gt____1 x = casadi__IMatrix____gt____1 (castIMatrix x)


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


-- classy wrapper
imatrix___le__ :: IMatrixClass a => a -> IMatrix -> IO IMatrix
imatrix___le__ x = casadi__IMatrix____le__ (castIMatrix x)


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


-- classy wrapper
imatrix___lt__ :: IMatrixClass a => a -> IMatrix -> IO IMatrix
imatrix___lt__ x = casadi__IMatrix____lt__ (castIMatrix x)


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


-- classy wrapper
imatrix___mldivide__ :: IMatrixClass a => a -> IMatrix -> IO IMatrix
imatrix___mldivide__ x = casadi__IMatrix____mldivide__ (castIMatrix x)


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


-- classy wrapper
imatrix___mpower__ :: IMatrixClass a => a -> IMatrix -> IO IMatrix
imatrix___mpower__ x = casadi__IMatrix____mpower__ (castIMatrix x)


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


-- classy wrapper
imatrix___mrdivide__ :: IMatrixClass a => a -> IMatrix -> IO IMatrix
imatrix___mrdivide__ x = casadi__IMatrix____mrdivide__ (castIMatrix x)


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


-- classy wrapper
imatrix___mul__ :: IMatrixClass a => a -> IMatrix -> IO IMatrix
imatrix___mul__ x = casadi__IMatrix____mul__ (castIMatrix x)


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


-- classy wrapper
imatrix___ne__ :: IMatrixClass a => a -> IMatrix -> IO IMatrix
imatrix___ne__ x = casadi__IMatrix____ne__ (castIMatrix x)


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


-- classy wrapper
imatrix___nonzero__ :: IMatrixClass a => a -> IO Bool
imatrix___nonzero__ x = casadi__IMatrix____nonzero__ (castIMatrix x)


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


-- classy wrapper
imatrix___pow__ :: IMatrixClass a => a -> IMatrix -> IO IMatrix
imatrix___pow__ x = casadi__IMatrix____pow__ (castIMatrix x)


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


-- classy wrapper
imatrix___radd__ :: IMatrixClass a => a -> IMatrix -> IO IMatrix
imatrix___radd__ x = casadi__IMatrix____radd__ (castIMatrix x)


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


-- classy wrapper
imatrix___rdiv__ :: IMatrixClass a => a -> IMatrix -> IO IMatrix
imatrix___rdiv__ x = casadi__IMatrix____rdiv__ (castIMatrix x)


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


-- classy wrapper
imatrix___req__ :: IMatrixClass a => a -> IMatrix -> IO IMatrix
imatrix___req__ x = casadi__IMatrix____req__ (castIMatrix x)


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


-- classy wrapper
imatrix___rge__ :: IMatrixClass a => a -> IMatrix -> IO IMatrix
imatrix___rge__ x = casadi__IMatrix____rge__ (castIMatrix x)


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


-- classy wrapper
imatrix___rgt__ :: IMatrixClass a => a -> IMatrix -> IO IMatrix
imatrix___rgt__ x = casadi__IMatrix____rgt__ (castIMatrix x)


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


-- classy wrapper
imatrix___rle__ :: IMatrixClass a => a -> IMatrix -> IO IMatrix
imatrix___rle__ x = casadi__IMatrix____rle__ (castIMatrix x)


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


-- classy wrapper
imatrix___rlt__ :: IMatrixClass a => a -> IMatrix -> IO IMatrix
imatrix___rlt__ x = casadi__IMatrix____rlt__ (castIMatrix x)


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


-- classy wrapper
imatrix___rmul__ :: IMatrixClass a => a -> IMatrix -> IO IMatrix
imatrix___rmul__ x = casadi__IMatrix____rmul__ (castIMatrix x)


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


-- classy wrapper
imatrix___rne__ :: IMatrixClass a => a -> IMatrix -> IO IMatrix
imatrix___rne__ x = casadi__IMatrix____rne__ (castIMatrix x)


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


-- classy wrapper
imatrix___rsub__ :: IMatrixClass a => a -> IMatrix -> IO IMatrix
imatrix___rsub__ x = casadi__IMatrix____rsub__ (castIMatrix x)


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


-- classy wrapper
imatrix___rtruediv__ :: IMatrixClass a => a -> IMatrix -> IO IMatrix
imatrix___rtruediv__ x = casadi__IMatrix____rtruediv__ (castIMatrix x)


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


-- classy wrapper
imatrix___sub__ :: IMatrixClass a => a -> IMatrix -> IO IMatrix
imatrix___sub__ x = casadi__IMatrix____sub__ (castIMatrix x)


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


-- classy wrapper
imatrix___truediv____0 :: IMatrixClass a => a -> IMatrix -> IO IMatrix
imatrix___truediv____0 x = casadi__IMatrix____truediv____0 (castIMatrix x)


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


-- classy wrapper
imatrix___truediv____1 :: IMatrixClass a => a -> IMatrix -> IO IMatrix
imatrix___truediv____1 x = casadi__IMatrix____truediv____1 (castIMatrix x)


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


-- classy wrapper
imatrix_append :: IMatrixClass a => a -> IMatrix -> IO ()
imatrix_append x = casadi__IMatrix__append (castIMatrix x)


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


-- classy wrapper
imatrix_appendColumns :: IMatrixClass a => a -> IMatrix -> IO ()
imatrix_appendColumns x = casadi__IMatrix__appendColumns (castIMatrix x)


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


-- classy wrapper
imatrix_arccos :: IMatrixClass a => a -> IO IMatrix
imatrix_arccos x = casadi__IMatrix__arccos (castIMatrix x)


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


-- classy wrapper
imatrix_arccosh :: IMatrixClass a => a -> IO IMatrix
imatrix_arccosh x = casadi__IMatrix__arccosh (castIMatrix x)


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


-- classy wrapper
imatrix_arcsin :: IMatrixClass a => a -> IO IMatrix
imatrix_arcsin x = casadi__IMatrix__arcsin (castIMatrix x)


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


-- classy wrapper
imatrix_arcsinh :: IMatrixClass a => a -> IO IMatrix
imatrix_arcsinh x = casadi__IMatrix__arcsinh (castIMatrix x)


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


-- classy wrapper
imatrix_arctan :: IMatrixClass a => a -> IO IMatrix
imatrix_arctan x = casadi__IMatrix__arctan (castIMatrix x)


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


-- classy wrapper
imatrix_arctan2 :: IMatrixClass a => a -> IMatrix -> IO IMatrix
imatrix_arctan2 x = casadi__IMatrix__arctan2 (castIMatrix x)


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


-- classy wrapper
imatrix_arctanh :: IMatrixClass a => a -> IO IMatrix
imatrix_arctanh x = casadi__IMatrix__arctanh (castIMatrix x)


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


-- classy wrapper
imatrix_at :: IMatrixClass a => a -> Int -> IO Int
imatrix_at x = casadi__IMatrix__at (castIMatrix x)


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


-- classy wrapper
imatrix_binary :: Int -> IMatrix -> IMatrix -> IO IMatrix
imatrix_binary = casadi__IMatrix__binary


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


-- classy wrapper
imatrix_ceil :: IMatrixClass a => a -> IO IMatrix
imatrix_ceil x = casadi__IMatrix__ceil (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "casadi__IMatrix__className" c_casadi__IMatrix__className
  :: Ptr (Ptr StdString) -> IO (Ptr StdString)
casadi__IMatrix__className
  :: IO String
casadi__IMatrix__className  =

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


-- classy wrapper
imatrix_className :: IO String
imatrix_className = casadi__IMatrix__className


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


-- classy wrapper
imatrix_clear :: IMatrixClass a => a -> IO ()
imatrix_clear x = casadi__IMatrix__clear (castIMatrix x)


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


-- classy wrapper
imatrix_colind__0 :: IMatrixClass a => a -> Int -> IO Int
imatrix_colind__0 x = casadi__IMatrix__colind__0 (castIMatrix x)


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


-- classy wrapper
imatrix_colind__1 :: IMatrixClass a => a -> IO (Vector Int)
imatrix_colind__1 x = casadi__IMatrix__colind__1 (castIMatrix x)


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


-- classy wrapper
imatrix_cos :: IMatrixClass a => a -> IO IMatrix
imatrix_cos x = casadi__IMatrix__cos (castIMatrix x)


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


-- classy wrapper
imatrix_cosh :: IMatrixClass a => a -> IO IMatrix
imatrix_cosh x = casadi__IMatrix__cosh (castIMatrix x)


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


-- classy wrapper
imatrix_data__0 :: IMatrixClass a => a -> IO (Vector Int)
imatrix_data__0 x = casadi__IMatrix__data__0 (castIMatrix x)


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


-- classy wrapper
imatrix_data__1 :: IMatrixClass a => a -> IO (Vector Int)
imatrix_data__1 x = casadi__IMatrix__data__1 (castIMatrix x)


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


-- classy wrapper
imatrix_densify__0 :: IMatrixClass a => a -> IO ()
imatrix_densify__0 x = casadi__IMatrix__densify__0 (castIMatrix x)


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


-- classy wrapper
imatrix_densify__1 :: IMatrixClass a => a -> Int -> IO ()
imatrix_densify__1 x = casadi__IMatrix__densify__1 (castIMatrix x)


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


-- classy wrapper
imatrix_dimString :: IMatrixClass a => a -> IO String
imatrix_dimString x = casadi__IMatrix__dimString (castIMatrix x)


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


-- classy wrapper
imatrix_elem__0 :: IMatrixClass a => a -> Int -> IO Int
imatrix_elem__0 x = casadi__IMatrix__elem__0 (castIMatrix x)


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


-- classy wrapper
imatrix_elem__1 :: IMatrixClass a => a -> Int -> Int -> IO Int
imatrix_elem__1 x = casadi__IMatrix__elem__1 (castIMatrix x)


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


-- classy wrapper
imatrix_enlarge :: IMatrixClass a => a -> Int -> Int -> Vector Int -> Vector Int -> IO ()
imatrix_enlarge x = casadi__IMatrix__enlarge (castIMatrix x)


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


-- classy wrapper
imatrix_erase :: IMatrixClass a => a -> Vector Int -> Vector Int -> IO ()
imatrix_erase x = casadi__IMatrix__erase (castIMatrix x)


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


-- classy wrapper
imatrix_erf :: IMatrixClass a => a -> IO IMatrix
imatrix_erf x = casadi__IMatrix__erf (castIMatrix x)


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


-- classy wrapper
imatrix_erfinv :: IMatrixClass a => a -> IO IMatrix
imatrix_erfinv x = casadi__IMatrix__erfinv (castIMatrix x)


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


-- classy wrapper
imatrix_exp :: IMatrixClass a => a -> IO IMatrix
imatrix_exp x = casadi__IMatrix__exp (castIMatrix x)


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


-- classy wrapper
imatrix_eye :: Int -> IO IMatrix
imatrix_eye = casadi__IMatrix__eye


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


-- classy wrapper
imatrix_fabs :: IMatrixClass a => a -> IO IMatrix
imatrix_fabs x = casadi__IMatrix__fabs (castIMatrix x)


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


-- classy wrapper
imatrix_floor :: IMatrixClass a => a -> IO IMatrix
imatrix_floor x = casadi__IMatrix__floor (castIMatrix x)


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


-- classy wrapper
imatrix_fmax :: IMatrixClass a => a -> IMatrix -> IO IMatrix
imatrix_fmax x = casadi__IMatrix__fmax (castIMatrix x)


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


-- classy wrapper
imatrix_fmin :: IMatrixClass a => a -> IMatrix -> IO IMatrix
imatrix_fmin x = casadi__IMatrix__fmin (castIMatrix x)


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


-- classy wrapper
imatrix_fmod :: IMatrixClass a => a -> IMatrix -> IO IMatrix
imatrix_fmod x = casadi__IMatrix__fmod (castIMatrix x)


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


-- classy wrapper
imatrix_get__0 :: IMatrixClass a => a -> IMatrix -> IO ()
imatrix_get__0 x = casadi__IMatrix__get__0 (castIMatrix x)


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


-- classy wrapper
imatrix_get__1 :: IMatrixClass a => a -> IMatrix -> SparsityType -> IO ()
imatrix_get__1 x = casadi__IMatrix__get__1 (castIMatrix x)


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


-- classy wrapper
imatrix_get__2 :: IMatrixClass a => a -> Vector Int -> IO ()
imatrix_get__2 x = casadi__IMatrix__get__2 (castIMatrix x)


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


-- classy wrapper
imatrix_get__3 :: IMatrixClass a => a -> Vector Int -> SparsityType -> IO ()
imatrix_get__3 x = casadi__IMatrix__get__3 (castIMatrix x)


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


-- classy wrapper
imatrix_get__4 :: IMatrixClass a => a -> Int -> IO ()
imatrix_get__4 x = casadi__IMatrix__get__4 (castIMatrix x)


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


-- classy wrapper
imatrix_get__5 :: IMatrixClass a => a -> Int -> SparsityType -> IO ()
imatrix_get__5 x = casadi__IMatrix__get__5 (castIMatrix x)


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


-- classy wrapper
imatrix_getElement__0 :: IMatrixClass a => a -> Int -> IO Int
imatrix_getElement__0 x = casadi__IMatrix__getElement__0 (castIMatrix x)


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


-- classy wrapper
imatrix_getElement__1 :: IMatrixClass a => a -> Int -> Int -> IO Int
imatrix_getElement__1 x = casadi__IMatrix__getElement__1 (castIMatrix x)


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

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


-- classy wrapper
imatrix_getEqualityCheckingDepth :: IO Int
imatrix_getEqualityCheckingDepth = casadi__IMatrix__getEqualityCheckingDepth


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

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


-- classy wrapper
imatrix_getMaxNumCallsInPrint :: IO Int
imatrix_getMaxNumCallsInPrint = casadi__IMatrix__getMaxNumCallsInPrint


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


-- classy wrapper
imatrix_getNZ__0 :: IMatrixClass a => a -> IMatrix -> IO IMatrix
imatrix_getNZ__0 x = casadi__IMatrix__getNZ__0 (castIMatrix x)


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


-- classy wrapper
imatrix_getNZ__1 :: IMatrixClass a => a -> Slice -> IO IMatrix
imatrix_getNZ__1 x = casadi__IMatrix__getNZ__1 (castIMatrix x)


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


-- classy wrapper
imatrix_getNZ__2 :: IMatrixClass a => a -> Vector Int -> IO IMatrix
imatrix_getNZ__2 x = casadi__IMatrix__getNZ__2 (castIMatrix x)


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


-- classy wrapper
imatrix_getNZ__3 :: IMatrixClass a => a -> Int -> IO IMatrix
imatrix_getNZ__3 x = casadi__IMatrix__getNZ__3 (castIMatrix x)


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


-- classy wrapper
imatrix_getName :: IMatrixClass a => a -> IO String
imatrix_getName x = casadi__IMatrix__getName (castIMatrix x)


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


-- classy wrapper
imatrix_getValue :: IMatrixClass a => a -> IO Double
imatrix_getValue x = casadi__IMatrix__getValue (castIMatrix x)


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


-- classy wrapper
imatrix_hasNZ :: IMatrixClass a => a -> Int -> Int -> IO Bool
imatrix_hasNZ x = casadi__IMatrix__hasNZ (castIMatrix x)


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


-- classy wrapper
imatrix_hasNonStructuralZeros :: IMatrixClass a => a -> IO Bool
imatrix_hasNonStructuralZeros x = casadi__IMatrix__hasNonStructuralZeros (castIMatrix x)


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


-- classy wrapper
imatrix_if_else_zero :: IMatrixClass a => a -> IMatrix -> IO IMatrix
imatrix_if_else_zero x = casadi__IMatrix__if_else_zero (castIMatrix x)


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


-- classy wrapper
imatrix_indexed__0 :: IMatrixClass a => a -> Slice -> IO IMatrix
imatrix_indexed__0 x = casadi__IMatrix__indexed__0 (castIMatrix x)


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


-- classy wrapper
imatrix_indexed__1 :: IMatrixClass a => a -> Sparsity -> IO IMatrix
imatrix_indexed__1 x = casadi__IMatrix__indexed__1 (castIMatrix x)


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


-- classy wrapper
imatrix_indexed__2 :: IMatrixClass a => a -> IMatrix -> IMatrix -> IO IMatrix
imatrix_indexed__2 x = casadi__IMatrix__indexed__2 (castIMatrix x)


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


-- classy wrapper
imatrix_indexed__3 :: IMatrixClass a => a -> IMatrix -> Slice -> IO IMatrix
imatrix_indexed__3 x = casadi__IMatrix__indexed__3 (castIMatrix x)


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


-- classy wrapper
imatrix_indexed__4 :: IMatrixClass a => a -> Slice -> IMatrix -> IO IMatrix
imatrix_indexed__4 x = casadi__IMatrix__indexed__4 (castIMatrix x)


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


-- classy wrapper
imatrix_indexed__5 :: IMatrixClass a => a -> Slice -> Slice -> IO IMatrix
imatrix_indexed__5 x = casadi__IMatrix__indexed__5 (castIMatrix x)


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


-- classy wrapper
imatrix_indexed_assignment__0 :: IMatrixClass a => a -> Slice -> IMatrix -> IO ()
imatrix_indexed_assignment__0 x = casadi__IMatrix__indexed_assignment__0 (castIMatrix x)


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


-- classy wrapper
imatrix_indexed_assignment__1 :: IMatrixClass a => a -> Sparsity -> IMatrix -> IO ()
imatrix_indexed_assignment__1 x = casadi__IMatrix__indexed_assignment__1 (castIMatrix x)


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


-- classy wrapper
imatrix_indexed_assignment__2 :: IMatrixClass a => a -> IMatrix -> IMatrix -> IMatrix -> IO ()
imatrix_indexed_assignment__2 x = casadi__IMatrix__indexed_assignment__2 (castIMatrix x)


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


-- classy wrapper
imatrix_indexed_assignment__3 :: IMatrixClass a => a -> IMatrix -> Slice -> IMatrix -> IO ()
imatrix_indexed_assignment__3 x = casadi__IMatrix__indexed_assignment__3 (castIMatrix x)


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


-- classy wrapper
imatrix_indexed_assignment__4 :: IMatrixClass a => a -> Slice -> IMatrix -> IMatrix -> IO ()
imatrix_indexed_assignment__4 x = casadi__IMatrix__indexed_assignment__4 (castIMatrix x)


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


-- classy wrapper
imatrix_indexed_assignment__5 :: IMatrixClass a => a -> Slice -> Slice -> IMatrix -> IO ()
imatrix_indexed_assignment__5 x = casadi__IMatrix__indexed_assignment__5 (castIMatrix x)


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


-- classy wrapper
imatrix_indexed_one_based__0 :: IMatrixClass a => a -> Int -> IO IMatrix
imatrix_indexed_one_based__0 x = casadi__IMatrix__indexed_one_based__0 (castIMatrix x)


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


-- classy wrapper
imatrix_indexed_one_based__1 :: IMatrixClass a => a -> Int -> Int -> IO IMatrix
imatrix_indexed_one_based__1 x = casadi__IMatrix__indexed_one_based__1 (castIMatrix x)


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


-- classy wrapper
imatrix_indexed_one_based__2 :: IMatrixClass a => a -> IMatrix -> IO IMatrix
imatrix_indexed_one_based__2 x = casadi__IMatrix__indexed_one_based__2 (castIMatrix x)


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


-- classy wrapper
imatrix_indexed_one_based_assignment__0 :: IMatrixClass a => a -> Int -> Int -> IO ()
imatrix_indexed_one_based_assignment__0 x = casadi__IMatrix__indexed_one_based_assignment__0 (castIMatrix x)


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


-- classy wrapper
imatrix_indexed_one_based_assignment__1 :: IMatrixClass a => a -> Int -> Int -> Int -> IO ()
imatrix_indexed_one_based_assignment__1 x = casadi__IMatrix__indexed_one_based_assignment__1 (castIMatrix x)


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


-- classy wrapper
imatrix_indexed_one_based_assignment__2 :: IMatrixClass a => a -> IMatrix -> IMatrix -> IO ()
imatrix_indexed_one_based_assignment__2 x = casadi__IMatrix__indexed_one_based_assignment__2 (castIMatrix x)


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


-- classy wrapper
imatrix_indexed_zero_based__0 :: IMatrixClass a => a -> Int -> IO IMatrix
imatrix_indexed_zero_based__0 x = casadi__IMatrix__indexed_zero_based__0 (castIMatrix x)


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


-- classy wrapper
imatrix_indexed_zero_based__1 :: IMatrixClass a => a -> Int -> Int -> IO IMatrix
imatrix_indexed_zero_based__1 x = casadi__IMatrix__indexed_zero_based__1 (castIMatrix x)


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


-- classy wrapper
imatrix_indexed_zero_based__2 :: IMatrixClass a => a -> IMatrix -> IO IMatrix
imatrix_indexed_zero_based__2 x = casadi__IMatrix__indexed_zero_based__2 (castIMatrix x)


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


-- classy wrapper
imatrix_indexed_zero_based_assignment__0 :: IMatrixClass a => a -> Int -> Int -> IO ()
imatrix_indexed_zero_based_assignment__0 x = casadi__IMatrix__indexed_zero_based_assignment__0 (castIMatrix x)


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


-- classy wrapper
imatrix_indexed_zero_based_assignment__1 :: IMatrixClass a => a -> Int -> Int -> Int -> IO ()
imatrix_indexed_zero_based_assignment__1 x = casadi__IMatrix__indexed_zero_based_assignment__1 (castIMatrix x)


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


-- classy wrapper
imatrix_indexed_zero_based_assignment__2 :: IMatrixClass a => a -> IMatrix -> IMatrix -> IO ()
imatrix_indexed_zero_based_assignment__2 x = casadi__IMatrix__indexed_zero_based_assignment__2 (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "casadi__IMatrix__inf__0" c_casadi__IMatrix__inf__0
  :: Ptr (Ptr StdString) -> IO (Ptr IMatrix')
casadi__IMatrix__inf__0
  :: IO IMatrix
casadi__IMatrix__inf__0  =

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


-- classy wrapper
imatrix_inf__0 :: IO IMatrix
imatrix_inf__0 = casadi__IMatrix__inf__0


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


-- classy wrapper
imatrix_inf__1 :: Int -> IO IMatrix
imatrix_inf__1 = casadi__IMatrix__inf__1


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


-- classy wrapper
imatrix_inf__2 :: Int -> Int -> IO IMatrix
imatrix_inf__2 = casadi__IMatrix__inf__2


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


-- classy wrapper
imatrix_inf__3 :: Sparsity -> IO IMatrix
imatrix_inf__3 = casadi__IMatrix__inf__3


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


-- classy wrapper
imatrix_isConstant :: IMatrixClass a => a -> IO Bool
imatrix_isConstant x = casadi__IMatrix__isConstant (castIMatrix x)


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


-- classy wrapper
imatrix_isDense :: IMatrixClass a => a -> IO Bool
imatrix_isDense x = casadi__IMatrix__isDense (castIMatrix x)


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


-- classy wrapper
imatrix_isEmpty__0 :: IMatrixClass a => a -> IO Bool
imatrix_isEmpty__0 x = casadi__IMatrix__isEmpty__0 (castIMatrix x)


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


-- classy wrapper
imatrix_isEmpty__1 :: IMatrixClass a => a -> Bool -> IO Bool
imatrix_isEmpty__1 x = casadi__IMatrix__isEmpty__1 (castIMatrix x)


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


-- classy wrapper
imatrix_isEqual :: IMatrixClass a => a -> IMatrix -> IO Bool
imatrix_isEqual x = casadi__IMatrix__isEqual (castIMatrix x)


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


-- classy wrapper
imatrix_isIdentity :: IMatrixClass a => a -> IO Bool
imatrix_isIdentity x = casadi__IMatrix__isIdentity (castIMatrix x)


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


-- classy wrapper
imatrix_isInteger :: IMatrixClass a => a -> IO Bool
imatrix_isInteger x = casadi__IMatrix__isInteger (castIMatrix x)


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


-- classy wrapper
imatrix_isMinusOne :: IMatrixClass a => a -> IO Bool
imatrix_isMinusOne x = casadi__IMatrix__isMinusOne (castIMatrix x)


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


-- classy wrapper
imatrix_isOne :: IMatrixClass a => a -> IO Bool
imatrix_isOne x = casadi__IMatrix__isOne (castIMatrix x)


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


-- classy wrapper
imatrix_isRegular :: IMatrixClass a => a -> IO Bool
imatrix_isRegular x = casadi__IMatrix__isRegular (castIMatrix x)


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


-- classy wrapper
imatrix_isScalar__0 :: IMatrixClass a => a -> IO Bool
imatrix_isScalar__0 x = casadi__IMatrix__isScalar__0 (castIMatrix x)


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


-- classy wrapper
imatrix_isScalar__1 :: IMatrixClass a => a -> Bool -> IO Bool
imatrix_isScalar__1 x = casadi__IMatrix__isScalar__1 (castIMatrix x)


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


-- classy wrapper
imatrix_isSmooth :: IMatrixClass a => a -> IO Bool
imatrix_isSmooth x = casadi__IMatrix__isSmooth (castIMatrix x)


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


-- classy wrapper
imatrix_isSquare :: IMatrixClass a => a -> IO Bool
imatrix_isSquare x = casadi__IMatrix__isSquare (castIMatrix x)


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


-- classy wrapper
imatrix_isSymbolic :: IMatrixClass a => a -> IO Bool
imatrix_isSymbolic x = casadi__IMatrix__isSymbolic (castIMatrix x)


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


-- classy wrapper
imatrix_isSymbolicSparse :: IMatrixClass a => a -> IO Bool
imatrix_isSymbolicSparse x = casadi__IMatrix__isSymbolicSparse (castIMatrix x)


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


-- classy wrapper
imatrix_isTril :: IMatrixClass a => a -> IO Bool
imatrix_isTril x = casadi__IMatrix__isTril (castIMatrix x)


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


-- classy wrapper
imatrix_isTriu :: IMatrixClass a => a -> IO Bool
imatrix_isTriu x = casadi__IMatrix__isTriu (castIMatrix x)


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


-- classy wrapper
imatrix_isVector :: IMatrixClass a => a -> IO Bool
imatrix_isVector x = casadi__IMatrix__isVector (castIMatrix x)


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


-- classy wrapper
imatrix_isZero :: IMatrixClass a => a -> IO Bool
imatrix_isZero x = casadi__IMatrix__isZero (castIMatrix x)


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


-- classy wrapper
imatrix_log :: IMatrixClass a => a -> IO IMatrix
imatrix_log x = casadi__IMatrix__log (castIMatrix x)


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


-- classy wrapper
imatrix_log10 :: IMatrixClass a => a -> IO IMatrix
imatrix_log10 x = casadi__IMatrix__log10 (castIMatrix x)


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


-- classy wrapper
imatrix_logic_and :: IMatrixClass a => a -> IMatrix -> IO IMatrix
imatrix_logic_and x = casadi__IMatrix__logic_and (castIMatrix x)


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


-- classy wrapper
imatrix_logic_not :: IMatrixClass a => a -> IO IMatrix
imatrix_logic_not x = casadi__IMatrix__logic_not (castIMatrix x)


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


-- classy wrapper
imatrix_logic_or :: IMatrixClass a => a -> IMatrix -> IO IMatrix
imatrix_logic_or x = casadi__IMatrix__logic_or (castIMatrix x)


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


-- classy wrapper
imatrix_matrix_matrix :: Int -> IMatrix -> IMatrix -> IO IMatrix
imatrix_matrix_matrix = casadi__IMatrix__matrix_matrix


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


-- classy wrapper
imatrix_matrix_scalar :: Int -> IMatrix -> IMatrix -> IO IMatrix
imatrix_matrix_scalar = casadi__IMatrix__matrix_scalar


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


-- classy wrapper
imatrix_mul__0 :: IMatrixClass a => a -> IMatrix -> IO IMatrix
imatrix_mul__0 x = casadi__IMatrix__mul__0 (castIMatrix x)


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


-- classy wrapper
imatrix_mul__1 :: IMatrixClass a => a -> IMatrix -> Sparsity -> IO IMatrix
imatrix_mul__1 x = casadi__IMatrix__mul__1 (castIMatrix x)


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


-- classy wrapper
imatrix_mul_full__0 :: IMatrixClass a => a -> IMatrix -> IO IMatrix
imatrix_mul_full__0 x = casadi__IMatrix__mul_full__0 (castIMatrix x)


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


-- classy wrapper
imatrix_mul_full__1 :: IMatrixClass a => a -> IMatrix -> Sparsity -> IO IMatrix
imatrix_mul_full__1 x = casadi__IMatrix__mul_full__1 (castIMatrix x)


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


-- classy wrapper
imatrix_mul_no_alloc_nn__0 :: IMatrix -> Vector Int -> Vector Int -> IO ()
imatrix_mul_no_alloc_nn__0 = casadi__IMatrix__mul_no_alloc_nn__0


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


-- classy wrapper
imatrix_mul_no_alloc_nn__1 :: IMatrix -> IMatrix -> IMatrix -> IO ()
imatrix_mul_no_alloc_nn__1 = casadi__IMatrix__mul_no_alloc_nn__1


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


-- classy wrapper
imatrix_mul_no_alloc_nt :: IMatrix -> IMatrix -> IMatrix -> IO ()
imatrix_mul_no_alloc_nt = casadi__IMatrix__mul_no_alloc_nt


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


-- classy wrapper
imatrix_mul_no_alloc_tn__0 :: IMatrix -> Vector Int -> Vector Int -> IO ()
imatrix_mul_no_alloc_tn__0 = casadi__IMatrix__mul_no_alloc_tn__0


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


-- classy wrapper
imatrix_mul_no_alloc_tn__1 :: IMatrix -> IMatrix -> IMatrix -> IO ()
imatrix_mul_no_alloc_tn__1 = casadi__IMatrix__mul_no_alloc_tn__1


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


-- classy wrapper
imatrix_mul_smart :: IMatrixClass a => a -> IMatrix -> Sparsity -> IO IMatrix
imatrix_mul_smart x = casadi__IMatrix__mul_smart (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "casadi__IMatrix__nan__0" c_casadi__IMatrix__nan__0
  :: Ptr (Ptr StdString) -> IO (Ptr IMatrix')
casadi__IMatrix__nan__0
  :: IO IMatrix
casadi__IMatrix__nan__0  =

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


-- classy wrapper
imatrix_nan__0 :: IO IMatrix
imatrix_nan__0 = casadi__IMatrix__nan__0


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


-- classy wrapper
imatrix_nan__1 :: Int -> IO IMatrix
imatrix_nan__1 = casadi__IMatrix__nan__1


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


-- classy wrapper
imatrix_nan__2 :: Int -> Int -> IO IMatrix
imatrix_nan__2 = casadi__IMatrix__nan__2


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


-- classy wrapper
imatrix_nan__3 :: Sparsity -> IO IMatrix
imatrix_nan__3 = casadi__IMatrix__nan__3


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


-- classy wrapper
imatrix_numel :: IMatrixClass a => a -> IO Int
imatrix_numel x = casadi__IMatrix__numel (castIMatrix x)


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


-- classy wrapper
imatrix_nz_indexed :: IMatrixClass a => a -> Slice -> IO IMatrix
imatrix_nz_indexed x = casadi__IMatrix__nz_indexed (castIMatrix x)


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


-- classy wrapper
imatrix_nz_indexed_assignment :: IMatrixClass a => a -> Slice -> IMatrix -> IO ()
imatrix_nz_indexed_assignment x = casadi__IMatrix__nz_indexed_assignment (castIMatrix x)


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


-- classy wrapper
imatrix_nz_indexed_one_based__0 :: IMatrixClass a => a -> IMatrix -> IO IMatrix
imatrix_nz_indexed_one_based__0 x = casadi__IMatrix__nz_indexed_one_based__0 (castIMatrix x)


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


-- classy wrapper
imatrix_nz_indexed_one_based__1 :: IMatrixClass a => a -> Int -> IO IMatrix
imatrix_nz_indexed_one_based__1 x = casadi__IMatrix__nz_indexed_one_based__1 (castIMatrix x)


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


-- classy wrapper
imatrix_nz_indexed_one_based_assignment__0 :: IMatrixClass a => a -> IMatrix -> IMatrix -> IO ()
imatrix_nz_indexed_one_based_assignment__0 x = casadi__IMatrix__nz_indexed_one_based_assignment__0 (castIMatrix x)


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


-- classy wrapper
imatrix_nz_indexed_one_based_assignment__1 :: IMatrixClass a => a -> Int -> Int -> IO ()
imatrix_nz_indexed_one_based_assignment__1 x = casadi__IMatrix__nz_indexed_one_based_assignment__1 (castIMatrix x)


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


-- classy wrapper
imatrix_nz_indexed_zero_based__0 :: IMatrixClass a => a -> IMatrix -> IO IMatrix
imatrix_nz_indexed_zero_based__0 x = casadi__IMatrix__nz_indexed_zero_based__0 (castIMatrix x)


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


-- classy wrapper
imatrix_nz_indexed_zero_based__1 :: IMatrixClass a => a -> Int -> IO IMatrix
imatrix_nz_indexed_zero_based__1 x = casadi__IMatrix__nz_indexed_zero_based__1 (castIMatrix x)


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


-- classy wrapper
imatrix_nz_indexed_zero_based_assignment__0 :: IMatrixClass a => a -> IMatrix -> IMatrix -> IO ()
imatrix_nz_indexed_zero_based_assignment__0 x = casadi__IMatrix__nz_indexed_zero_based_assignment__0 (castIMatrix x)


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


-- classy wrapper
imatrix_nz_indexed_zero_based_assignment__1 :: IMatrixClass a => a -> Int -> Int -> IO ()
imatrix_nz_indexed_zero_based_assignment__1 x = casadi__IMatrix__nz_indexed_zero_based_assignment__1 (castIMatrix x)


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


-- classy wrapper
imatrix_ones__0 :: Sparsity -> IO IMatrix
imatrix_ones__0 = casadi__IMatrix__ones__0


-- direct wrapper
foreign import ccall unsafe "casadi__IMatrix__ones__1" c_casadi__IMatrix__ones__1
  :: Ptr (Ptr StdString) -> IO (Ptr IMatrix')
casadi__IMatrix__ones__1
  :: IO IMatrix
casadi__IMatrix__ones__1  =

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


-- classy wrapper
imatrix_ones__1 :: IO IMatrix
imatrix_ones__1 = casadi__IMatrix__ones__1


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


-- classy wrapper
imatrix_ones__2 :: Int -> IO IMatrix
imatrix_ones__2 = casadi__IMatrix__ones__2


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


-- classy wrapper
imatrix_ones__3 :: Int -> Int -> IO IMatrix
imatrix_ones__3 = casadi__IMatrix__ones__3


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


-- classy wrapper
imatrix_printDense :: IMatrixClass a => a -> IO ()
imatrix_printDense x = casadi__IMatrix__printDense (castIMatrix x)


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


-- classy wrapper
imatrix_printScalar :: IMatrixClass a => a -> IO ()
imatrix_printScalar x = casadi__IMatrix__printScalar (castIMatrix x)


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


-- classy wrapper
imatrix_printSparse :: IMatrixClass a => a -> IO ()
imatrix_printSparse x = casadi__IMatrix__printSparse (castIMatrix x)


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


-- classy wrapper
imatrix_printVector :: IMatrixClass a => a -> IO ()
imatrix_printVector x = casadi__IMatrix__printVector (castIMatrix x)


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


-- classy wrapper
imatrix_printme :: IMatrixClass a => a -> IMatrix -> IO IMatrix
imatrix_printme x = casadi__IMatrix__printme (castIMatrix x)


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


-- classy wrapper
imatrix_quad_form :: IMatrix -> Vector Int -> IO Int
imatrix_quad_form = casadi__IMatrix__quad_form


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


-- classy wrapper
imatrix_remove :: IMatrixClass a => a -> Vector Int -> Vector Int -> IO ()
imatrix_remove x = casadi__IMatrix__remove (castIMatrix x)


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


-- classy wrapper
imatrix_repmat__0 :: IMatrix -> Int -> IO IMatrix
imatrix_repmat__0 = casadi__IMatrix__repmat__0


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


-- classy wrapper
imatrix_repmat__1 :: IMatrix -> Int -> Int -> IO IMatrix
imatrix_repmat__1 = casadi__IMatrix__repmat__1


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


-- classy wrapper
imatrix_repmat__2 :: IMatrix -> Sparsity -> IO IMatrix
imatrix_repmat__2 = casadi__IMatrix__repmat__2


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


-- classy wrapper
imatrix_repmat__3 :: Int -> Sparsity -> IO IMatrix
imatrix_repmat__3 = casadi__IMatrix__repmat__3


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


-- classy wrapper
imatrix_reserve__0 :: IMatrixClass a => a -> Int -> Int -> IO ()
imatrix_reserve__0 x = casadi__IMatrix__reserve__0 (castIMatrix x)


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


-- classy wrapper
imatrix_reserve__1 :: IMatrixClass a => a -> Int -> IO ()
imatrix_reserve__1 x = casadi__IMatrix__reserve__1 (castIMatrix x)


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


-- classy wrapper
imatrix_resize :: IMatrixClass a => a -> Int -> Int -> IO ()
imatrix_resize x = casadi__IMatrix__resize (castIMatrix x)


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


-- classy wrapper
imatrix_row__0 :: IMatrixClass a => a -> Int -> IO Int
imatrix_row__0 x = casadi__IMatrix__row__0 (castIMatrix x)


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


-- classy wrapper
imatrix_row__1 :: IMatrixClass a => a -> IO (Vector Int)
imatrix_row__1 x = casadi__IMatrix__row__1 (castIMatrix x)


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


-- classy wrapper
imatrix_sanityCheck__0 :: IMatrixClass a => a -> IO ()
imatrix_sanityCheck__0 x = casadi__IMatrix__sanityCheck__0 (castIMatrix x)


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


-- classy wrapper
imatrix_sanityCheck__1 :: IMatrixClass a => a -> Bool -> IO ()
imatrix_sanityCheck__1 x = casadi__IMatrix__sanityCheck__1 (castIMatrix x)


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


-- classy wrapper
imatrix_scalar_matrix :: Int -> IMatrix -> IMatrix -> IO IMatrix
imatrix_scalar_matrix = casadi__IMatrix__scalar_matrix


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


-- classy wrapper
imatrix_set__0 :: IMatrixClass a => a -> IMatrix -> IO ()
imatrix_set__0 x = casadi__IMatrix__set__0 (castIMatrix x)


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


-- classy wrapper
imatrix_set__1 :: IMatrixClass a => a -> IMatrix -> SparsityType -> IO ()
imatrix_set__1 x = casadi__IMatrix__set__1 (castIMatrix x)


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


-- classy wrapper
imatrix_set__2 :: IMatrixClass a => a -> Vector Int -> IO ()
imatrix_set__2 x = casadi__IMatrix__set__2 (castIMatrix x)


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


-- classy wrapper
imatrix_set__3 :: IMatrixClass a => a -> Vector Int -> SparsityType -> IO ()
imatrix_set__3 x = casadi__IMatrix__set__3 (castIMatrix x)


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


-- classy wrapper
imatrix_set__4 :: IMatrixClass a => a -> Int -> IO ()
imatrix_set__4 x = casadi__IMatrix__set__4 (castIMatrix x)


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


-- classy wrapper
imatrix_set__5 :: IMatrixClass a => a -> Int -> SparsityType -> IO ()
imatrix_set__5 x = casadi__IMatrix__set__5 (castIMatrix x)


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


-- classy wrapper
imatrix_setAll :: IMatrixClass a => a -> Int -> IO ()
imatrix_setAll x = casadi__IMatrix__setAll (castIMatrix x)


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

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


-- classy wrapper
imatrix_setEqualityCheckingDepth__0 :: IO ()
imatrix_setEqualityCheckingDepth__0 = casadi__IMatrix__setEqualityCheckingDepth__0


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


-- classy wrapper
imatrix_setEqualityCheckingDepth__1 :: Int -> IO ()
imatrix_setEqualityCheckingDepth__1 = casadi__IMatrix__setEqualityCheckingDepth__1


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

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


-- classy wrapper
imatrix_setMaxNumCallsInPrint__0 :: IO ()
imatrix_setMaxNumCallsInPrint__0 = casadi__IMatrix__setMaxNumCallsInPrint__0


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


-- classy wrapper
imatrix_setMaxNumCallsInPrint__1 :: Int -> IO ()
imatrix_setMaxNumCallsInPrint__1 = casadi__IMatrix__setMaxNumCallsInPrint__1


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


-- classy wrapper
imatrix_setNZ__0 :: IMatrixClass a => a -> IMatrix -> IMatrix -> IO ()
imatrix_setNZ__0 x = casadi__IMatrix__setNZ__0 (castIMatrix x)


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


-- classy wrapper
imatrix_setNZ__1 :: IMatrixClass a => a -> Slice -> IMatrix -> IO ()
imatrix_setNZ__1 x = casadi__IMatrix__setNZ__1 (castIMatrix x)


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


-- classy wrapper
imatrix_setNZ__2 :: IMatrixClass a => a -> Vector Int -> IMatrix -> IO ()
imatrix_setNZ__2 x = casadi__IMatrix__setNZ__2 (castIMatrix x)


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


-- classy wrapper
imatrix_setNZ__3 :: IMatrixClass a => a -> Int -> IMatrix -> IO ()
imatrix_setNZ__3 x = casadi__IMatrix__setNZ__3 (castIMatrix x)


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


-- classy wrapper
imatrix_setPrecision :: Int -> IO ()
imatrix_setPrecision = casadi__IMatrix__setPrecision


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


-- classy wrapper
imatrix_setScientific :: Bool -> IO ()
imatrix_setScientific = casadi__IMatrix__setScientific


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


-- classy wrapper
imatrix_setSparse__0 :: IMatrixClass a => a -> Sparsity -> IO IMatrix
imatrix_setSparse__0 x = casadi__IMatrix__setSparse__0 (castIMatrix x)


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


-- classy wrapper
imatrix_setSparse__1 :: IMatrixClass a => a -> Sparsity -> Bool -> IO IMatrix
imatrix_setSparse__1 x = casadi__IMatrix__setSparse__1 (castIMatrix x)


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


-- classy wrapper
imatrix_setSub__0 :: IMatrixClass a => a -> IMatrix -> Sparsity -> Int -> IO ()
imatrix_setSub__0 x = casadi__IMatrix__setSub__0 (castIMatrix x)


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


-- classy wrapper
imatrix_setSub__1 :: IMatrixClass a => a -> IMatrix -> Int -> Slice -> IO ()
imatrix_setSub__1 x = casadi__IMatrix__setSub__1 (castIMatrix x)


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


-- classy wrapper
imatrix_setSub__2 :: IMatrixClass a => a -> IMatrix -> Slice -> Int -> IO ()
imatrix_setSub__2 x = casadi__IMatrix__setSub__2 (castIMatrix x)


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


-- classy wrapper
imatrix_setSub__3 :: IMatrixClass a => a -> IMatrix -> IMatrix -> IMatrix -> IO ()
imatrix_setSub__3 x = casadi__IMatrix__setSub__3 (castIMatrix x)


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


-- classy wrapper
imatrix_setSub__4 :: IMatrixClass a => a -> IMatrix -> Slice -> IMatrix -> IO ()
imatrix_setSub__4 x = casadi__IMatrix__setSub__4 (castIMatrix x)


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


-- classy wrapper
imatrix_setSub__5 :: IMatrixClass a => a -> IMatrix -> IMatrix -> Slice -> IO ()
imatrix_setSub__5 x = casadi__IMatrix__setSub__5 (castIMatrix x)


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


-- classy wrapper
imatrix_setSub__6 :: IMatrixClass a => a -> IMatrix -> Int -> IMatrix -> IO ()
imatrix_setSub__6 x = casadi__IMatrix__setSub__6 (castIMatrix x)


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


-- classy wrapper
imatrix_setSub__7 :: IMatrixClass a => a -> IMatrix -> Vector Int -> IMatrix -> IO ()
imatrix_setSub__7 x = casadi__IMatrix__setSub__7 (castIMatrix x)


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


-- classy wrapper
imatrix_setSub__8 :: IMatrixClass a => a -> IMatrix -> IMatrix -> Int -> IO ()
imatrix_setSub__8 x = casadi__IMatrix__setSub__8 (castIMatrix x)


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


-- classy wrapper
imatrix_setSub__9 :: IMatrixClass a => a -> IMatrix -> IMatrix -> Vector Int -> IO ()
imatrix_setSub__9 x = casadi__IMatrix__setSub__9 (castIMatrix x)


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


-- classy wrapper
imatrix_setSub__10 :: IMatrixClass a => a -> IMatrix -> Slice -> Slice -> IO ()
imatrix_setSub__10 x = casadi__IMatrix__setSub__10 (castIMatrix x)


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


-- classy wrapper
imatrix_setSub__11 :: IMatrixClass a => a -> IMatrix -> Vector Int -> Slice -> IO ()
imatrix_setSub__11 x = casadi__IMatrix__setSub__11 (castIMatrix x)


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


-- classy wrapper
imatrix_setSub__12 :: IMatrixClass a => a -> IMatrix -> Slice -> Vector Int -> IO ()
imatrix_setSub__12 x = casadi__IMatrix__setSub__12 (castIMatrix x)


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


-- classy wrapper
imatrix_setSub__13 :: IMatrixClass a => a -> IMatrix -> Vector Int -> Vector Int -> IO ()
imatrix_setSub__13 x = casadi__IMatrix__setSub__13 (castIMatrix x)


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


-- classy wrapper
imatrix_setSub__14 :: IMatrixClass a => a -> IMatrix -> Int -> Vector Int -> IO ()
imatrix_setSub__14 x = casadi__IMatrix__setSub__14 (castIMatrix x)


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


-- classy wrapper
imatrix_setSub__15 :: IMatrixClass a => a -> IMatrix -> Vector Int -> Int -> IO ()
imatrix_setSub__15 x = casadi__IMatrix__setSub__15 (castIMatrix x)


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


-- classy wrapper
imatrix_setSub__16 :: IMatrixClass a => a -> IMatrix -> Int -> Int -> IO ()
imatrix_setSub__16 x = casadi__IMatrix__setSub__16 (castIMatrix x)


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


-- classy wrapper
imatrix_setWidth :: Int -> IO ()
imatrix_setWidth = casadi__IMatrix__setWidth


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


-- classy wrapper
imatrix_setZero :: IMatrixClass a => a -> IO ()
imatrix_setZero x = casadi__IMatrix__setZero (castIMatrix x)


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


-- classy wrapper
imatrix_sign :: IMatrixClass a => a -> IO IMatrix
imatrix_sign x = casadi__IMatrix__sign (castIMatrix x)


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


-- classy wrapper
imatrix_sin :: IMatrixClass a => a -> IO IMatrix
imatrix_sin x = casadi__IMatrix__sin (castIMatrix x)


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


-- classy wrapper
imatrix_sinh :: IMatrixClass a => a -> IO IMatrix
imatrix_sinh x = casadi__IMatrix__sinh (castIMatrix x)


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


-- classy wrapper
imatrix_size__0 :: IMatrixClass a => a -> SparsityType -> IO Int
imatrix_size__0 x = casadi__IMatrix__size__0 (castIMatrix x)


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


-- classy wrapper
imatrix_size__1 :: IMatrixClass a => a -> IO Int
imatrix_size__1 x = casadi__IMatrix__size__1 (castIMatrix x)


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


-- classy wrapper
imatrix_size1 :: IMatrixClass a => a -> IO Int
imatrix_size1 x = casadi__IMatrix__size1 (castIMatrix x)


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


-- classy wrapper
imatrix_size2 :: IMatrixClass a => a -> IO Int
imatrix_size2 x = casadi__IMatrix__size2 (castIMatrix x)


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


-- classy wrapper
imatrix_sizeD :: IMatrixClass a => a -> IO Int
imatrix_sizeD x = casadi__IMatrix__sizeD (castIMatrix x)


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


-- classy wrapper
imatrix_sizeL :: IMatrixClass a => a -> IO Int
imatrix_sizeL x = casadi__IMatrix__sizeL (castIMatrix x)


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


-- classy wrapper
imatrix_sizeU :: IMatrixClass a => a -> IO Int
imatrix_sizeU x = casadi__IMatrix__sizeU (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "casadi__IMatrix__sparse__0" c_casadi__IMatrix__sparse__0
  :: Ptr (Ptr StdString) -> IO (Ptr IMatrix')
casadi__IMatrix__sparse__0
  :: IO IMatrix
casadi__IMatrix__sparse__0  =

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


-- classy wrapper
imatrix_sparse__0 :: IO IMatrix
imatrix_sparse__0 = casadi__IMatrix__sparse__0


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


-- classy wrapper
imatrix_sparse__1 :: Int -> IO IMatrix
imatrix_sparse__1 = casadi__IMatrix__sparse__1


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


-- classy wrapper
imatrix_sparse__2 :: Int -> Int -> IO IMatrix
imatrix_sparse__2 = casadi__IMatrix__sparse__2


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


-- classy wrapper
imatrix_sparsify__0 :: IMatrixClass a => a -> IO ()
imatrix_sparsify__0 x = casadi__IMatrix__sparsify__0 (castIMatrix x)


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


-- classy wrapper
imatrix_sparsify__1 :: IMatrixClass a => a -> Double -> IO ()
imatrix_sparsify__1 x = casadi__IMatrix__sparsify__1 (castIMatrix x)


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


-- classy wrapper
imatrix_sparsity__0 :: IMatrixClass a => a -> IO Sparsity
imatrix_sparsity__0 x = casadi__IMatrix__sparsity__0 (castIMatrix x)


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


-- classy wrapper
imatrix_sparsity__1 :: IMatrixClass a => a -> IO Sparsity
imatrix_sparsity__1 x = casadi__IMatrix__sparsity__1 (castIMatrix x)


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


-- classy wrapper
imatrix_sparsityRef__0 :: IMatrixClass a => a -> IO Sparsity
imatrix_sparsityRef__0 x = casadi__IMatrix__sparsityRef__0 (castIMatrix x)


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


-- classy wrapper
imatrix_sparsityRef__1 :: IMatrixClass a => a -> IO Sparsity
imatrix_sparsityRef__1 x = casadi__IMatrix__sparsityRef__1 (castIMatrix x)


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


-- classy wrapper
imatrix_sqrt :: IMatrixClass a => a -> IO IMatrix
imatrix_sqrt x = casadi__IMatrix__sqrt (castIMatrix x)


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


-- classy wrapper
imatrix_sub__0 :: IMatrixClass a => a -> Sparsity -> IO IMatrix
imatrix_sub__0 x = casadi__IMatrix__sub__0 (castIMatrix x)


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


-- classy wrapper
imatrix_sub__1 :: IMatrixClass a => a -> Sparsity -> Int -> IO IMatrix
imatrix_sub__1 x = casadi__IMatrix__sub__1 (castIMatrix x)


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


-- classy wrapper
imatrix_sub__2 :: IMatrixClass a => a -> IMatrix -> IMatrix -> IO IMatrix
imatrix_sub__2 x = casadi__IMatrix__sub__2 (castIMatrix x)


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


-- classy wrapper
imatrix_sub__3 :: IMatrixClass a => a -> Slice -> IMatrix -> IO IMatrix
imatrix_sub__3 x = casadi__IMatrix__sub__3 (castIMatrix x)


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


-- classy wrapper
imatrix_sub__4 :: IMatrixClass a => a -> IMatrix -> Slice -> IO IMatrix
imatrix_sub__4 x = casadi__IMatrix__sub__4 (castIMatrix x)


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


-- classy wrapper
imatrix_sub__5 :: IMatrixClass a => a -> Int -> IMatrix -> IO IMatrix
imatrix_sub__5 x = casadi__IMatrix__sub__5 (castIMatrix x)


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


-- classy wrapper
imatrix_sub__6 :: IMatrixClass a => a -> Vector Int -> IMatrix -> IO IMatrix
imatrix_sub__6 x = casadi__IMatrix__sub__6 (castIMatrix x)


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


-- classy wrapper
imatrix_sub__7 :: IMatrixClass a => a -> IMatrix -> Int -> IO IMatrix
imatrix_sub__7 x = casadi__IMatrix__sub__7 (castIMatrix x)


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


-- classy wrapper
imatrix_sub__8 :: IMatrixClass a => a -> IMatrix -> Vector Int -> IO IMatrix
imatrix_sub__8 x = casadi__IMatrix__sub__8 (castIMatrix x)


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


-- classy wrapper
imatrix_sub__9 :: IMatrixClass a => a -> Int -> Slice -> IO IMatrix
imatrix_sub__9 x = casadi__IMatrix__sub__9 (castIMatrix x)


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


-- classy wrapper
imatrix_sub__10 :: IMatrixClass a => a -> Slice -> Int -> IO IMatrix
imatrix_sub__10 x = casadi__IMatrix__sub__10 (castIMatrix x)


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


-- classy wrapper
imatrix_sub__11 :: IMatrixClass a => a -> Slice -> Slice -> IO IMatrix
imatrix_sub__11 x = casadi__IMatrix__sub__11 (castIMatrix x)


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


-- classy wrapper
imatrix_sub__12 :: IMatrixClass a => a -> Vector Int -> Slice -> IO IMatrix
imatrix_sub__12 x = casadi__IMatrix__sub__12 (castIMatrix x)


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


-- classy wrapper
imatrix_sub__13 :: IMatrixClass a => a -> Slice -> Vector Int -> IO IMatrix
imatrix_sub__13 x = casadi__IMatrix__sub__13 (castIMatrix x)


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


-- classy wrapper
imatrix_sub__14 :: IMatrixClass a => a -> Vector Int -> Vector Int -> IO IMatrix
imatrix_sub__14 x = casadi__IMatrix__sub__14 (castIMatrix x)


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


-- classy wrapper
imatrix_sub__15 :: IMatrixClass a => a -> Int -> Vector Int -> IO IMatrix
imatrix_sub__15 x = casadi__IMatrix__sub__15 (castIMatrix x)


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


-- classy wrapper
imatrix_sub__16 :: IMatrixClass a => a -> Vector Int -> Int -> IO IMatrix
imatrix_sub__16 x = casadi__IMatrix__sub__16 (castIMatrix x)


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


-- classy wrapper
imatrix_sub__17 :: IMatrixClass a => a -> Int -> Int -> IO IMatrix
imatrix_sub__17 x = casadi__IMatrix__sub__17 (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "casadi__IMatrix__sym__0" c_casadi__IMatrix__sym__0
  :: Ptr (Ptr StdString) -> Ptr StdString -> CInt -> CInt -> CInt -> CInt -> IO (Ptr (StdVec (Ptr (StdVec (Ptr IMatrix')))))
casadi__IMatrix__sym__0
  :: String -> Int -> Int -> Int -> Int -> IO (Vector (Vector IMatrix))
casadi__IMatrix__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__IMatrix__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
imatrix_sym__0 :: String -> Int -> Int -> Int -> Int -> IO (Vector (Vector IMatrix))
imatrix_sym__0 = casadi__IMatrix__sym__0


-- direct wrapper
foreign import ccall unsafe "casadi__IMatrix__sym__1" c_casadi__IMatrix__sym__1
  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> CInt -> CInt -> IO (Ptr (StdVec (Ptr (StdVec (Ptr IMatrix')))))
casadi__IMatrix__sym__1
  :: String -> Sparsity -> Int -> Int -> IO (Vector (Vector IMatrix))
casadi__IMatrix__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__IMatrix__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
imatrix_sym__1 :: String -> Sparsity -> Int -> Int -> IO (Vector (Vector IMatrix))
imatrix_sym__1 = casadi__IMatrix__sym__1


-- direct wrapper
foreign import ccall unsafe "casadi__IMatrix__sym__2" c_casadi__IMatrix__sym__2
  :: Ptr (Ptr StdString) -> Ptr StdString -> CInt -> CInt -> CInt -> IO (Ptr (StdVec (Ptr IMatrix')))
casadi__IMatrix__sym__2
  :: String -> Int -> Int -> Int -> IO (Vector IMatrix)
casadi__IMatrix__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__IMatrix__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
imatrix_sym__2 :: String -> Int -> Int -> Int -> IO (Vector IMatrix)
imatrix_sym__2 = casadi__IMatrix__sym__2


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


-- classy wrapper
imatrix_sym__3 :: String -> Sparsity -> Int -> IO (Vector IMatrix)
imatrix_sym__3 = casadi__IMatrix__sym__3


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


-- classy wrapper
imatrix_sym__4 :: String -> Sparsity -> IO IMatrix
imatrix_sym__4 = casadi__IMatrix__sym__4


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


-- classy wrapper
imatrix_sym__5 :: String -> IO IMatrix
imatrix_sym__5 = casadi__IMatrix__sym__5


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


-- classy wrapper
imatrix_sym__6 :: String -> Int -> IO IMatrix
imatrix_sym__6 = casadi__IMatrix__sym__6


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


-- classy wrapper
imatrix_sym__7 :: String -> Int -> Int -> IO IMatrix
imatrix_sym__7 = casadi__IMatrix__sym__7


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


-- classy wrapper
imatrix_tan :: IMatrixClass a => a -> IO IMatrix
imatrix_tan x = casadi__IMatrix__tan (castIMatrix x)


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


-- classy wrapper
imatrix_tanh :: IMatrixClass a => a -> IO IMatrix
imatrix_tanh x = casadi__IMatrix__tanh (castIMatrix x)


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


-- classy wrapper
imatrix_toScalar :: IMatrixClass a => a -> IO Int
imatrix_toScalar x = casadi__IMatrix__toScalar (castIMatrix x)


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


-- classy wrapper
imatrix_trans :: IMatrixClass a => a -> IO IMatrix
imatrix_trans x = casadi__IMatrix__trans (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "casadi__IMatrix__triplet__0" c_casadi__IMatrix__triplet__0
  :: Ptr (Ptr StdString) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> CInt -> CInt -> IO (Ptr IMatrix')
casadi__IMatrix__triplet__0
  :: Vector Int -> Vector Int -> Vector Int -> Int -> Int -> IO IMatrix
casadi__IMatrix__triplet__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__IMatrix__triplet__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
imatrix_triplet__0 :: Vector Int -> Vector Int -> Vector Int -> Int -> Int -> IO IMatrix
imatrix_triplet__0 = casadi__IMatrix__triplet__0


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


-- classy wrapper
imatrix_triplet__1 :: Vector Int -> Vector Int -> Vector Int -> IO IMatrix
imatrix_triplet__1 = casadi__IMatrix__triplet__1


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


-- classy wrapper
imatrix_unary :: Int -> IMatrix -> IO IMatrix
imatrix_unary = casadi__IMatrix__unary


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


-- classy wrapper
imatrix_zeros__0 :: Sparsity -> IO IMatrix
imatrix_zeros__0 = casadi__IMatrix__zeros__0


-- direct wrapper
foreign import ccall unsafe "casadi__IMatrix__zeros__1" c_casadi__IMatrix__zeros__1
  :: Ptr (Ptr StdString) -> IO (Ptr IMatrix')
casadi__IMatrix__zeros__1
  :: IO IMatrix
casadi__IMatrix__zeros__1  =

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


-- classy wrapper
imatrix_zeros__1 :: IO IMatrix
imatrix_zeros__1 = casadi__IMatrix__zeros__1


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


-- classy wrapper
imatrix_zeros__2 :: Int -> IO IMatrix
imatrix_zeros__2 = casadi__IMatrix__zeros__2


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


-- classy wrapper
imatrix_zeros__3 :: Int -> Int -> IO IMatrix
imatrix_zeros__3 = casadi__IMatrix__zeros__3