casadi-bindings-core-2.1.0.0: Casadi/Core/Classes/DMatrix.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.DMatrix
       (
         DMatrix,
         DMatrixClass(..),
         dmatrix__0,
         dmatrix__1,
         dmatrix__10,
         dmatrix__11,
         dmatrix__2,
         dmatrix__3,
         dmatrix__4,
         dmatrix__5,
         dmatrix__6,
         dmatrix__7,
         dmatrix__8,
         dmatrix__9,
         dmatrix___add__,
         dmatrix___constpow__,
         dmatrix___copysign__,
         dmatrix___div__,
         dmatrix___eq__,
         dmatrix___ge____0,
         dmatrix___ge____1,
         dmatrix___gt____0,
         dmatrix___gt____1,
         dmatrix___le__,
         dmatrix___lt__,
         dmatrix___mldivide__,
         dmatrix___mpower__,
         dmatrix___mrdivide__,
         dmatrix___mul__,
         dmatrix___ne__,
         dmatrix___nonzero__,
         dmatrix___pow__,
         dmatrix___radd__,
         dmatrix___rdiv__,
         dmatrix___req__,
         dmatrix___rge__,
         dmatrix___rgt__,
         dmatrix___rle__,
         dmatrix___rlt__,
         dmatrix___rmul__,
         dmatrix___rne__,
         dmatrix___rsub__,
         dmatrix___rtruediv__,
         dmatrix___sub__,
         dmatrix___truediv____0,
         dmatrix___truediv____1,
         dmatrix_append,
         dmatrix_appendColumns,
         dmatrix_arccos,
         dmatrix_arccosh,
         dmatrix_arcsin,
         dmatrix_arcsinh,
         dmatrix_arctan,
         dmatrix_arctan2,
         dmatrix_arctanh,
         dmatrix_at,
         dmatrix_binary,
         dmatrix_ceil,
         dmatrix_className,
         dmatrix_clear,
         dmatrix_colind__0,
         dmatrix_colind__1,
         dmatrix_cos,
         dmatrix_cosh,
         dmatrix_data__0,
         dmatrix_data__1,
         dmatrix_densify__0,
         dmatrix_densify__1,
         dmatrix_dimString,
         dmatrix_elem__0,
         dmatrix_elem__1,
         dmatrix_enlarge,
         dmatrix_erase,
         dmatrix_erf,
         dmatrix_erfinv,
         dmatrix_exp,
         dmatrix_eye,
         dmatrix_fabs,
         dmatrix_floor,
         dmatrix_fmax,
         dmatrix_fmin,
         dmatrix_fmod,
         dmatrix_getElement__0,
         dmatrix_getElement__1,
         dmatrix_getEqualityCheckingDepth,
         dmatrix_getMaxNumCallsInPrint,
         dmatrix_getNZ__0,
         dmatrix_getNZ__1,
         dmatrix_getNZ__2,
         dmatrix_getNZ__3,
         dmatrix_getName,
         dmatrix_getValue,
         dmatrix_get__0,
         dmatrix_get__1,
         dmatrix_get__2,
         dmatrix_get__3,
         dmatrix_get__4,
         dmatrix_get__5,
         dmatrix_hasNZ,
         dmatrix_hasNonStructuralZeros,
         dmatrix_if_else_zero,
         dmatrix_indexed__0,
         dmatrix_indexed__1,
         dmatrix_indexed__2,
         dmatrix_indexed__3,
         dmatrix_indexed__4,
         dmatrix_indexed__5,
         dmatrix_indexed_assignment__0,
         dmatrix_indexed_assignment__1,
         dmatrix_indexed_assignment__2,
         dmatrix_indexed_assignment__3,
         dmatrix_indexed_assignment__4,
         dmatrix_indexed_assignment__5,
         dmatrix_indexed_one_based__0,
         dmatrix_indexed_one_based__1,
         dmatrix_indexed_one_based__2,
         dmatrix_indexed_one_based_assignment__0,
         dmatrix_indexed_one_based_assignment__1,
         dmatrix_indexed_one_based_assignment__2,
         dmatrix_indexed_zero_based__0,
         dmatrix_indexed_zero_based__1,
         dmatrix_indexed_zero_based__2,
         dmatrix_indexed_zero_based_assignment__0,
         dmatrix_indexed_zero_based_assignment__1,
         dmatrix_indexed_zero_based_assignment__2,
         dmatrix_inf__0,
         dmatrix_inf__1,
         dmatrix_inf__2,
         dmatrix_inf__3,
         dmatrix_isConstant,
         dmatrix_isDense,
         dmatrix_isEmpty__0,
         dmatrix_isEmpty__1,
         dmatrix_isEqual,
         dmatrix_isIdentity,
         dmatrix_isInteger,
         dmatrix_isMinusOne,
         dmatrix_isOne,
         dmatrix_isRegular,
         dmatrix_isScalar__0,
         dmatrix_isScalar__1,
         dmatrix_isSmooth,
         dmatrix_isSquare,
         dmatrix_isSymbolic,
         dmatrix_isSymbolicSparse,
         dmatrix_isTril,
         dmatrix_isTriu,
         dmatrix_isVector,
         dmatrix_isZero,
         dmatrix_log,
         dmatrix_log10,
         dmatrix_logic_and,
         dmatrix_logic_not,
         dmatrix_logic_or,
         dmatrix_matrix_matrix,
         dmatrix_matrix_scalar,
         dmatrix_mul__0,
         dmatrix_mul__1,
         dmatrix_mul_full__0,
         dmatrix_mul_full__1,
         dmatrix_mul_no_alloc_nn__0,
         dmatrix_mul_no_alloc_nn__1,
         dmatrix_mul_no_alloc_nn__2,
         dmatrix_mul_no_alloc_nt,
         dmatrix_mul_no_alloc_tn__0,
         dmatrix_mul_no_alloc_tn__1,
         dmatrix_mul_smart,
         dmatrix_nan__0,
         dmatrix_nan__1,
         dmatrix_nan__2,
         dmatrix_nan__3,
         dmatrix_numel,
         dmatrix_nz_indexed,
         dmatrix_nz_indexed_assignment,
         dmatrix_nz_indexed_one_based__0,
         dmatrix_nz_indexed_one_based__1,
         dmatrix_nz_indexed_one_based_assignment__0,
         dmatrix_nz_indexed_one_based_assignment__1,
         dmatrix_nz_indexed_zero_based__0,
         dmatrix_nz_indexed_zero_based__1,
         dmatrix_nz_indexed_zero_based_assignment__0,
         dmatrix_nz_indexed_zero_based_assignment__1,
         dmatrix_ones__0,
         dmatrix_ones__1,
         dmatrix_ones__2,
         dmatrix_ones__3,
         dmatrix_printDense,
         dmatrix_printScalar,
         dmatrix_printSparse,
         dmatrix_printVector,
         dmatrix_printme,
         dmatrix_quad_form,
         dmatrix_remove,
         dmatrix_repmat__0,
         dmatrix_repmat__1,
         dmatrix_repmat__2,
         dmatrix_repmat__3,
         dmatrix_reserve__0,
         dmatrix_reserve__1,
         dmatrix_resize,
         dmatrix_row__0,
         dmatrix_row__1,
         dmatrix_sanityCheck__0,
         dmatrix_sanityCheck__1,
         dmatrix_scalar_matrix,
         dmatrix_setAll,
         dmatrix_setEqualityCheckingDepth__0,
         dmatrix_setEqualityCheckingDepth__1,
         dmatrix_setMaxNumCallsInPrint__0,
         dmatrix_setMaxNumCallsInPrint__1,
         dmatrix_setNZ__0,
         dmatrix_setNZ__1,
         dmatrix_setNZ__2,
         dmatrix_setNZ__3,
         dmatrix_setPrecision,
         dmatrix_setScientific,
         dmatrix_setSparse__0,
         dmatrix_setSparse__1,
         dmatrix_setSub__0,
         dmatrix_setSub__1,
         dmatrix_setSub__10,
         dmatrix_setSub__11,
         dmatrix_setSub__12,
         dmatrix_setSub__13,
         dmatrix_setSub__14,
         dmatrix_setSub__15,
         dmatrix_setSub__16,
         dmatrix_setSub__2,
         dmatrix_setSub__3,
         dmatrix_setSub__4,
         dmatrix_setSub__5,
         dmatrix_setSub__6,
         dmatrix_setSub__7,
         dmatrix_setSub__8,
         dmatrix_setSub__9,
         dmatrix_setWidth,
         dmatrix_setZero,
         dmatrix_set__0,
         dmatrix_set__1,
         dmatrix_set__2,
         dmatrix_set__3,
         dmatrix_set__4,
         dmatrix_set__5,
         dmatrix_sign,
         dmatrix_sin,
         dmatrix_sinh,
         dmatrix_size1,
         dmatrix_size2,
         dmatrix_sizeD,
         dmatrix_sizeL,
         dmatrix_sizeU,
         dmatrix_size__0,
         dmatrix_size__1,
         dmatrix_sparse__0,
         dmatrix_sparse__1,
         dmatrix_sparse__2,
         dmatrix_sparsify__0,
         dmatrix_sparsify__1,
         dmatrix_sparsityRef__0,
         dmatrix_sparsityRef__1,
         dmatrix_sparsity__0,
         dmatrix_sparsity__1,
         dmatrix_sqrt,
         dmatrix_sub__0,
         dmatrix_sub__1,
         dmatrix_sub__10,
         dmatrix_sub__11,
         dmatrix_sub__12,
         dmatrix_sub__13,
         dmatrix_sub__14,
         dmatrix_sub__15,
         dmatrix_sub__16,
         dmatrix_sub__17,
         dmatrix_sub__2,
         dmatrix_sub__3,
         dmatrix_sub__4,
         dmatrix_sub__5,
         dmatrix_sub__6,
         dmatrix_sub__7,
         dmatrix_sub__8,
         dmatrix_sub__9,
         dmatrix_sym__0,
         dmatrix_sym__1,
         dmatrix_sym__2,
         dmatrix_sym__3,
         dmatrix_sym__4,
         dmatrix_sym__5,
         dmatrix_sym__6,
         dmatrix_sym__7,
         dmatrix_tan,
         dmatrix_tanh,
         dmatrix_toScalar,
         dmatrix_trans,
         dmatrix_triplet__0,
         dmatrix_triplet__1,
         dmatrix_unary,
         dmatrix_zeros__0,
         dmatrix_zeros__1,
         dmatrix_zeros__2,
         dmatrix_zeros__3,
       ) where


import Prelude hiding ( Functor )

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

import Casadi.Internal.CToolsInstances ( )
import Casadi.Internal.FormatException ( formatException )
import Casadi.Internal.MarshalTypes ( StdVec, StdString) -- StdPair StdOstream'
import Casadi.Internal.Marshal ( Marshal(..), withMarshal )
import Casadi.Internal.WrapReturn ( WrapReturn(..) )
import Casadi.Core.Data
import Casadi.Core.Enums

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


-- classy wrapper
dmatrix__0 :: Vector Int -> Int -> Int -> IO DMatrix
dmatrix__0 = casadi__DMatrix__CONSTRUCTOR__0


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


-- classy wrapper
dmatrix__1 :: Vector Int -> IO DMatrix
dmatrix__1 = casadi__DMatrix__CONSTRUCTOR__1


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


-- classy wrapper
dmatrix__2 :: IMatrix -> IO DMatrix
dmatrix__2 = casadi__DMatrix__CONSTRUCTOR__2


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


-- classy wrapper
dmatrix__3 :: Vector Double -> Int -> Int -> IO DMatrix
dmatrix__3 = casadi__DMatrix__CONSTRUCTOR__3


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


-- classy wrapper
dmatrix__4 :: Vector Double -> IO DMatrix
dmatrix__4 = casadi__DMatrix__CONSTRUCTOR__4


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


-- classy wrapper
dmatrix__5 :: Double -> IO DMatrix
dmatrix__5 = casadi__DMatrix__CONSTRUCTOR__5


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


-- classy wrapper
dmatrix__6 :: Sparsity -> Vector Double -> IO DMatrix
dmatrix__6 = casadi__DMatrix__CONSTRUCTOR__6


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


-- classy wrapper
dmatrix__7 :: Sparsity -> IO DMatrix
dmatrix__7 = casadi__DMatrix__CONSTRUCTOR__7


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


-- classy wrapper
dmatrix__8 :: Sparsity -> Double -> IO DMatrix
dmatrix__8 = casadi__DMatrix__CONSTRUCTOR__8


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


-- classy wrapper
dmatrix__9 :: Vector (Vector Double) -> IO DMatrix
dmatrix__9 = casadi__DMatrix__CONSTRUCTOR__9


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


-- classy wrapper
dmatrix__10 :: DMatrix -> IO DMatrix
dmatrix__10 = casadi__DMatrix__CONSTRUCTOR__10


-- direct wrapper
foreign import ccall unsafe "casadi__DMatrix__CONSTRUCTOR__11" c_casadi__DMatrix__CONSTRUCTOR__11
  :: Ptr (Ptr StdString) -> IO (Ptr DMatrix')
casadi__DMatrix__CONSTRUCTOR__11
  :: IO DMatrix
casadi__DMatrix__CONSTRUCTOR__11  =

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


-- classy wrapper
dmatrix__11 :: IO DMatrix
dmatrix__11 = casadi__DMatrix__CONSTRUCTOR__11


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


-- classy wrapper
dmatrix___add__ :: DMatrixClass a => a -> DMatrix -> IO DMatrix
dmatrix___add__ x = casadi__DMatrix____add__ (castDMatrix x)


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


-- classy wrapper
dmatrix___constpow__ :: DMatrixClass a => a -> DMatrix -> IO DMatrix
dmatrix___constpow__ x = casadi__DMatrix____constpow__ (castDMatrix x)


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


-- classy wrapper
dmatrix___copysign__ :: DMatrixClass a => a -> DMatrix -> IO DMatrix
dmatrix___copysign__ x = casadi__DMatrix____copysign__ (castDMatrix x)


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


-- classy wrapper
dmatrix___div__ :: DMatrixClass a => a -> DMatrix -> IO DMatrix
dmatrix___div__ x = casadi__DMatrix____div__ (castDMatrix x)


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


-- classy wrapper
dmatrix___eq__ :: DMatrixClass a => a -> DMatrix -> IO DMatrix
dmatrix___eq__ x = casadi__DMatrix____eq__ (castDMatrix x)


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


-- classy wrapper
dmatrix___ge____0 :: DMatrixClass a => a -> DMatrix -> IO DMatrix
dmatrix___ge____0 x = casadi__DMatrix____ge____0 (castDMatrix x)


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


-- classy wrapper
dmatrix___ge____1 :: DMatrixClass a => a -> DMatrix -> IO DMatrix
dmatrix___ge____1 x = casadi__DMatrix____ge____1 (castDMatrix x)


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


-- classy wrapper
dmatrix___gt____0 :: DMatrixClass a => a -> DMatrix -> IO DMatrix
dmatrix___gt____0 x = casadi__DMatrix____gt____0 (castDMatrix x)


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


-- classy wrapper
dmatrix___gt____1 :: DMatrixClass a => a -> DMatrix -> IO DMatrix
dmatrix___gt____1 x = casadi__DMatrix____gt____1 (castDMatrix x)


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


-- classy wrapper
dmatrix___le__ :: DMatrixClass a => a -> DMatrix -> IO DMatrix
dmatrix___le__ x = casadi__DMatrix____le__ (castDMatrix x)


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


-- classy wrapper
dmatrix___lt__ :: DMatrixClass a => a -> DMatrix -> IO DMatrix
dmatrix___lt__ x = casadi__DMatrix____lt__ (castDMatrix x)


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


-- classy wrapper
dmatrix___mldivide__ :: DMatrixClass a => a -> DMatrix -> IO DMatrix
dmatrix___mldivide__ x = casadi__DMatrix____mldivide__ (castDMatrix x)


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


-- classy wrapper
dmatrix___mpower__ :: DMatrixClass a => a -> DMatrix -> IO DMatrix
dmatrix___mpower__ x = casadi__DMatrix____mpower__ (castDMatrix x)


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


-- classy wrapper
dmatrix___mrdivide__ :: DMatrixClass a => a -> DMatrix -> IO DMatrix
dmatrix___mrdivide__ x = casadi__DMatrix____mrdivide__ (castDMatrix x)


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


-- classy wrapper
dmatrix___mul__ :: DMatrixClass a => a -> DMatrix -> IO DMatrix
dmatrix___mul__ x = casadi__DMatrix____mul__ (castDMatrix x)


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


-- classy wrapper
dmatrix___ne__ :: DMatrixClass a => a -> DMatrix -> IO DMatrix
dmatrix___ne__ x = casadi__DMatrix____ne__ (castDMatrix x)


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


-- classy wrapper
dmatrix___nonzero__ :: DMatrixClass a => a -> IO Bool
dmatrix___nonzero__ x = casadi__DMatrix____nonzero__ (castDMatrix x)


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


-- classy wrapper
dmatrix___pow__ :: DMatrixClass a => a -> DMatrix -> IO DMatrix
dmatrix___pow__ x = casadi__DMatrix____pow__ (castDMatrix x)


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


-- classy wrapper
dmatrix___radd__ :: DMatrixClass a => a -> DMatrix -> IO DMatrix
dmatrix___radd__ x = casadi__DMatrix____radd__ (castDMatrix x)


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


-- classy wrapper
dmatrix___rdiv__ :: DMatrixClass a => a -> DMatrix -> IO DMatrix
dmatrix___rdiv__ x = casadi__DMatrix____rdiv__ (castDMatrix x)


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


-- classy wrapper
dmatrix___req__ :: DMatrixClass a => a -> DMatrix -> IO DMatrix
dmatrix___req__ x = casadi__DMatrix____req__ (castDMatrix x)


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


-- classy wrapper
dmatrix___rge__ :: DMatrixClass a => a -> DMatrix -> IO DMatrix
dmatrix___rge__ x = casadi__DMatrix____rge__ (castDMatrix x)


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


-- classy wrapper
dmatrix___rgt__ :: DMatrixClass a => a -> DMatrix -> IO DMatrix
dmatrix___rgt__ x = casadi__DMatrix____rgt__ (castDMatrix x)


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


-- classy wrapper
dmatrix___rle__ :: DMatrixClass a => a -> DMatrix -> IO DMatrix
dmatrix___rle__ x = casadi__DMatrix____rle__ (castDMatrix x)


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


-- classy wrapper
dmatrix___rlt__ :: DMatrixClass a => a -> DMatrix -> IO DMatrix
dmatrix___rlt__ x = casadi__DMatrix____rlt__ (castDMatrix x)


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


-- classy wrapper
dmatrix___rmul__ :: DMatrixClass a => a -> DMatrix -> IO DMatrix
dmatrix___rmul__ x = casadi__DMatrix____rmul__ (castDMatrix x)


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


-- classy wrapper
dmatrix___rne__ :: DMatrixClass a => a -> DMatrix -> IO DMatrix
dmatrix___rne__ x = casadi__DMatrix____rne__ (castDMatrix x)


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


-- classy wrapper
dmatrix___rsub__ :: DMatrixClass a => a -> DMatrix -> IO DMatrix
dmatrix___rsub__ x = casadi__DMatrix____rsub__ (castDMatrix x)


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


-- classy wrapper
dmatrix___rtruediv__ :: DMatrixClass a => a -> DMatrix -> IO DMatrix
dmatrix___rtruediv__ x = casadi__DMatrix____rtruediv__ (castDMatrix x)


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


-- classy wrapper
dmatrix___sub__ :: DMatrixClass a => a -> DMatrix -> IO DMatrix
dmatrix___sub__ x = casadi__DMatrix____sub__ (castDMatrix x)


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


-- classy wrapper
dmatrix___truediv____0 :: DMatrixClass a => a -> DMatrix -> IO DMatrix
dmatrix___truediv____0 x = casadi__DMatrix____truediv____0 (castDMatrix x)


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


-- classy wrapper
dmatrix___truediv____1 :: DMatrixClass a => a -> DMatrix -> IO DMatrix
dmatrix___truediv____1 x = casadi__DMatrix____truediv____1 (castDMatrix x)


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


-- classy wrapper
dmatrix_append :: DMatrixClass a => a -> DMatrix -> IO ()
dmatrix_append x = casadi__DMatrix__append (castDMatrix x)


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


-- classy wrapper
dmatrix_appendColumns :: DMatrixClass a => a -> DMatrix -> IO ()
dmatrix_appendColumns x = casadi__DMatrix__appendColumns (castDMatrix x)


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


-- classy wrapper
dmatrix_arccos :: DMatrixClass a => a -> IO DMatrix
dmatrix_arccos x = casadi__DMatrix__arccos (castDMatrix x)


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


-- classy wrapper
dmatrix_arccosh :: DMatrixClass a => a -> IO DMatrix
dmatrix_arccosh x = casadi__DMatrix__arccosh (castDMatrix x)


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


-- classy wrapper
dmatrix_arcsin :: DMatrixClass a => a -> IO DMatrix
dmatrix_arcsin x = casadi__DMatrix__arcsin (castDMatrix x)


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


-- classy wrapper
dmatrix_arcsinh :: DMatrixClass a => a -> IO DMatrix
dmatrix_arcsinh x = casadi__DMatrix__arcsinh (castDMatrix x)


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


-- classy wrapper
dmatrix_arctan :: DMatrixClass a => a -> IO DMatrix
dmatrix_arctan x = casadi__DMatrix__arctan (castDMatrix x)


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


-- classy wrapper
dmatrix_arctan2 :: DMatrixClass a => a -> DMatrix -> IO DMatrix
dmatrix_arctan2 x = casadi__DMatrix__arctan2 (castDMatrix x)


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


-- classy wrapper
dmatrix_arctanh :: DMatrixClass a => a -> IO DMatrix
dmatrix_arctanh x = casadi__DMatrix__arctanh (castDMatrix x)


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


-- classy wrapper
dmatrix_at :: DMatrixClass a => a -> Int -> IO Double
dmatrix_at x = casadi__DMatrix__at (castDMatrix x)


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


-- classy wrapper
dmatrix_binary :: Int -> DMatrix -> DMatrix -> IO DMatrix
dmatrix_binary = casadi__DMatrix__binary


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


-- classy wrapper
dmatrix_ceil :: DMatrixClass a => a -> IO DMatrix
dmatrix_ceil x = casadi__DMatrix__ceil (castDMatrix x)


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

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


-- classy wrapper
dmatrix_className :: IO String
dmatrix_className = casadi__DMatrix__className


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


-- classy wrapper
dmatrix_clear :: DMatrixClass a => a -> IO ()
dmatrix_clear x = casadi__DMatrix__clear (castDMatrix x)


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


-- classy wrapper
dmatrix_colind__0 :: DMatrixClass a => a -> Int -> IO Int
dmatrix_colind__0 x = casadi__DMatrix__colind__0 (castDMatrix x)


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


-- classy wrapper
dmatrix_colind__1 :: DMatrixClass a => a -> IO (Vector Int)
dmatrix_colind__1 x = casadi__DMatrix__colind__1 (castDMatrix x)


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


-- classy wrapper
dmatrix_cos :: DMatrixClass a => a -> IO DMatrix
dmatrix_cos x = casadi__DMatrix__cos (castDMatrix x)


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


-- classy wrapper
dmatrix_cosh :: DMatrixClass a => a -> IO DMatrix
dmatrix_cosh x = casadi__DMatrix__cosh (castDMatrix x)


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


-- classy wrapper
dmatrix_data__0 :: DMatrixClass a => a -> IO (Vector Double)
dmatrix_data__0 x = casadi__DMatrix__data__0 (castDMatrix x)


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


-- classy wrapper
dmatrix_data__1 :: DMatrixClass a => a -> IO (Vector Double)
dmatrix_data__1 x = casadi__DMatrix__data__1 (castDMatrix x)


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


-- classy wrapper
dmatrix_densify__0 :: DMatrixClass a => a -> IO ()
dmatrix_densify__0 x = casadi__DMatrix__densify__0 (castDMatrix x)


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


-- classy wrapper
dmatrix_densify__1 :: DMatrixClass a => a -> Double -> IO ()
dmatrix_densify__1 x = casadi__DMatrix__densify__1 (castDMatrix x)


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


-- classy wrapper
dmatrix_dimString :: DMatrixClass a => a -> IO String
dmatrix_dimString x = casadi__DMatrix__dimString (castDMatrix x)


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


-- classy wrapper
dmatrix_elem__0 :: DMatrixClass a => a -> Int -> IO Double
dmatrix_elem__0 x = casadi__DMatrix__elem__0 (castDMatrix x)


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


-- classy wrapper
dmatrix_elem__1 :: DMatrixClass a => a -> Int -> Int -> IO Double
dmatrix_elem__1 x = casadi__DMatrix__elem__1 (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "casadi__DMatrix__enlarge" c_casadi__DMatrix__enlarge
  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> CInt -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO ()
casadi__DMatrix__enlarge
  :: DMatrix -> Int -> Int -> Vector Int -> Vector Int -> IO ()
casadi__DMatrix__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__DMatrix__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
dmatrix_enlarge :: DMatrixClass a => a -> Int -> Int -> Vector Int -> Vector Int -> IO ()
dmatrix_enlarge x = casadi__DMatrix__enlarge (castDMatrix x)


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


-- classy wrapper
dmatrix_erase :: DMatrixClass a => a -> Vector Int -> Vector Int -> IO ()
dmatrix_erase x = casadi__DMatrix__erase (castDMatrix x)


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


-- classy wrapper
dmatrix_erf :: DMatrixClass a => a -> IO DMatrix
dmatrix_erf x = casadi__DMatrix__erf (castDMatrix x)


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


-- classy wrapper
dmatrix_erfinv :: DMatrixClass a => a -> IO DMatrix
dmatrix_erfinv x = casadi__DMatrix__erfinv (castDMatrix x)


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


-- classy wrapper
dmatrix_exp :: DMatrixClass a => a -> IO DMatrix
dmatrix_exp x = casadi__DMatrix__exp (castDMatrix x)


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


-- classy wrapper
dmatrix_eye :: Int -> IO DMatrix
dmatrix_eye = casadi__DMatrix__eye


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


-- classy wrapper
dmatrix_fabs :: DMatrixClass a => a -> IO DMatrix
dmatrix_fabs x = casadi__DMatrix__fabs (castDMatrix x)


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


-- classy wrapper
dmatrix_floor :: DMatrixClass a => a -> IO DMatrix
dmatrix_floor x = casadi__DMatrix__floor (castDMatrix x)


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


-- classy wrapper
dmatrix_fmax :: DMatrixClass a => a -> DMatrix -> IO DMatrix
dmatrix_fmax x = casadi__DMatrix__fmax (castDMatrix x)


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


-- classy wrapper
dmatrix_fmin :: DMatrixClass a => a -> DMatrix -> IO DMatrix
dmatrix_fmin x = casadi__DMatrix__fmin (castDMatrix x)


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


-- classy wrapper
dmatrix_fmod :: DMatrixClass a => a -> DMatrix -> IO DMatrix
dmatrix_fmod x = casadi__DMatrix__fmod (castDMatrix x)


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


-- classy wrapper
dmatrix_get__0 :: DMatrixClass a => a -> DMatrix -> IO ()
dmatrix_get__0 x = casadi__DMatrix__get__0 (castDMatrix x)


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


-- classy wrapper
dmatrix_get__1 :: DMatrixClass a => a -> DMatrix -> SparsityType -> IO ()
dmatrix_get__1 x = casadi__DMatrix__get__1 (castDMatrix x)


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


-- classy wrapper
dmatrix_get__2 :: DMatrixClass a => a -> Vector Double -> IO ()
dmatrix_get__2 x = casadi__DMatrix__get__2 (castDMatrix x)


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


-- classy wrapper
dmatrix_get__3 :: DMatrixClass a => a -> Vector Double -> SparsityType -> IO ()
dmatrix_get__3 x = casadi__DMatrix__get__3 (castDMatrix x)


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


-- classy wrapper
dmatrix_get__4 :: DMatrixClass a => a -> Double -> IO ()
dmatrix_get__4 x = casadi__DMatrix__get__4 (castDMatrix x)


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


-- classy wrapper
dmatrix_get__5 :: DMatrixClass a => a -> Double -> SparsityType -> IO ()
dmatrix_get__5 x = casadi__DMatrix__get__5 (castDMatrix x)


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


-- classy wrapper
dmatrix_getElement__0 :: DMatrixClass a => a -> Int -> IO Double
dmatrix_getElement__0 x = casadi__DMatrix__getElement__0 (castDMatrix x)


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


-- classy wrapper
dmatrix_getElement__1 :: DMatrixClass a => a -> Int -> Int -> IO Double
dmatrix_getElement__1 x = casadi__DMatrix__getElement__1 (castDMatrix x)


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

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


-- classy wrapper
dmatrix_getEqualityCheckingDepth :: IO Int
dmatrix_getEqualityCheckingDepth = casadi__DMatrix__getEqualityCheckingDepth


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

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


-- classy wrapper
dmatrix_getMaxNumCallsInPrint :: IO Int
dmatrix_getMaxNumCallsInPrint = casadi__DMatrix__getMaxNumCallsInPrint


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


-- classy wrapper
dmatrix_getNZ__0 :: DMatrixClass a => a -> IMatrix -> IO DMatrix
dmatrix_getNZ__0 x = casadi__DMatrix__getNZ__0 (castDMatrix x)


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


-- classy wrapper
dmatrix_getNZ__1 :: DMatrixClass a => a -> Slice -> IO DMatrix
dmatrix_getNZ__1 x = casadi__DMatrix__getNZ__1 (castDMatrix x)


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


-- classy wrapper
dmatrix_getNZ__2 :: DMatrixClass a => a -> Vector Int -> IO DMatrix
dmatrix_getNZ__2 x = casadi__DMatrix__getNZ__2 (castDMatrix x)


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


-- classy wrapper
dmatrix_getNZ__3 :: DMatrixClass a => a -> Int -> IO DMatrix
dmatrix_getNZ__3 x = casadi__DMatrix__getNZ__3 (castDMatrix x)


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


-- classy wrapper
dmatrix_getName :: DMatrixClass a => a -> IO String
dmatrix_getName x = casadi__DMatrix__getName (castDMatrix x)


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


-- classy wrapper
dmatrix_getValue :: DMatrixClass a => a -> IO Double
dmatrix_getValue x = casadi__DMatrix__getValue (castDMatrix x)


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


-- classy wrapper
dmatrix_hasNZ :: DMatrixClass a => a -> Int -> Int -> IO Bool
dmatrix_hasNZ x = casadi__DMatrix__hasNZ (castDMatrix x)


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


-- classy wrapper
dmatrix_hasNonStructuralZeros :: DMatrixClass a => a -> IO Bool
dmatrix_hasNonStructuralZeros x = casadi__DMatrix__hasNonStructuralZeros (castDMatrix x)


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


-- classy wrapper
dmatrix_if_else_zero :: DMatrixClass a => a -> DMatrix -> IO DMatrix
dmatrix_if_else_zero x = casadi__DMatrix__if_else_zero (castDMatrix x)


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


-- classy wrapper
dmatrix_indexed__0 :: DMatrixClass a => a -> Slice -> IO DMatrix
dmatrix_indexed__0 x = casadi__DMatrix__indexed__0 (castDMatrix x)


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


-- classy wrapper
dmatrix_indexed__1 :: DMatrixClass a => a -> Sparsity -> IO DMatrix
dmatrix_indexed__1 x = casadi__DMatrix__indexed__1 (castDMatrix x)


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


-- classy wrapper
dmatrix_indexed__2 :: DMatrixClass a => a -> IMatrix -> IMatrix -> IO DMatrix
dmatrix_indexed__2 x = casadi__DMatrix__indexed__2 (castDMatrix x)


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


-- classy wrapper
dmatrix_indexed__3 :: DMatrixClass a => a -> IMatrix -> Slice -> IO DMatrix
dmatrix_indexed__3 x = casadi__DMatrix__indexed__3 (castDMatrix x)


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


-- classy wrapper
dmatrix_indexed__4 :: DMatrixClass a => a -> Slice -> IMatrix -> IO DMatrix
dmatrix_indexed__4 x = casadi__DMatrix__indexed__4 (castDMatrix x)


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


-- classy wrapper
dmatrix_indexed__5 :: DMatrixClass a => a -> Slice -> Slice -> IO DMatrix
dmatrix_indexed__5 x = casadi__DMatrix__indexed__5 (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "casadi__DMatrix__indexed_assignment__0" c_casadi__DMatrix__indexed_assignment__0
  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr Slice' -> Ptr DMatrix' -> IO ()
casadi__DMatrix__indexed_assignment__0
  :: DMatrix -> Slice -> DMatrix -> IO ()
casadi__DMatrix__indexed_assignment__0 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__DMatrix__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
dmatrix_indexed_assignment__0 :: DMatrixClass a => a -> Slice -> DMatrix -> IO ()
dmatrix_indexed_assignment__0 x = casadi__DMatrix__indexed_assignment__0 (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "casadi__DMatrix__indexed_assignment__1" c_casadi__DMatrix__indexed_assignment__1
  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr Sparsity' -> Ptr DMatrix' -> IO ()
casadi__DMatrix__indexed_assignment__1
  :: DMatrix -> Sparsity -> DMatrix -> IO ()
casadi__DMatrix__indexed_assignment__1 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__DMatrix__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
dmatrix_indexed_assignment__1 :: DMatrixClass a => a -> Sparsity -> DMatrix -> IO ()
dmatrix_indexed_assignment__1 x = casadi__DMatrix__indexed_assignment__1 (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "casadi__DMatrix__indexed_assignment__2" c_casadi__DMatrix__indexed_assignment__2
  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr DMatrix' -> IO ()
casadi__DMatrix__indexed_assignment__2
  :: DMatrix -> IMatrix -> IMatrix -> DMatrix -> IO ()
casadi__DMatrix__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__DMatrix__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
dmatrix_indexed_assignment__2 :: DMatrixClass a => a -> IMatrix -> IMatrix -> DMatrix -> IO ()
dmatrix_indexed_assignment__2 x = casadi__DMatrix__indexed_assignment__2 (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "casadi__DMatrix__indexed_assignment__3" c_casadi__DMatrix__indexed_assignment__3
  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr IMatrix' -> Ptr Slice' -> Ptr DMatrix' -> IO ()
casadi__DMatrix__indexed_assignment__3
  :: DMatrix -> IMatrix -> Slice -> DMatrix -> IO ()
casadi__DMatrix__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__DMatrix__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
dmatrix_indexed_assignment__3 :: DMatrixClass a => a -> IMatrix -> Slice -> DMatrix -> IO ()
dmatrix_indexed_assignment__3 x = casadi__DMatrix__indexed_assignment__3 (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "casadi__DMatrix__indexed_assignment__4" c_casadi__DMatrix__indexed_assignment__4
  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr Slice' -> Ptr IMatrix' -> Ptr DMatrix' -> IO ()
casadi__DMatrix__indexed_assignment__4
  :: DMatrix -> Slice -> IMatrix -> DMatrix -> IO ()
casadi__DMatrix__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__DMatrix__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
dmatrix_indexed_assignment__4 :: DMatrixClass a => a -> Slice -> IMatrix -> DMatrix -> IO ()
dmatrix_indexed_assignment__4 x = casadi__DMatrix__indexed_assignment__4 (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "casadi__DMatrix__indexed_assignment__5" c_casadi__DMatrix__indexed_assignment__5
  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr Slice' -> Ptr Slice' -> Ptr DMatrix' -> IO ()
casadi__DMatrix__indexed_assignment__5
  :: DMatrix -> Slice -> Slice -> DMatrix -> IO ()
casadi__DMatrix__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__DMatrix__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
dmatrix_indexed_assignment__5 :: DMatrixClass a => a -> Slice -> Slice -> DMatrix -> IO ()
dmatrix_indexed_assignment__5 x = casadi__DMatrix__indexed_assignment__5 (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "casadi__DMatrix__indexed_one_based__0" c_casadi__DMatrix__indexed_one_based__0
  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> IO (Ptr DMatrix')
casadi__DMatrix__indexed_one_based__0
  :: DMatrix -> Int -> IO DMatrix
casadi__DMatrix__indexed_one_based__0 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__DMatrix__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
dmatrix_indexed_one_based__0 :: DMatrixClass a => a -> Int -> IO DMatrix
dmatrix_indexed_one_based__0 x = casadi__DMatrix__indexed_one_based__0 (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "casadi__DMatrix__indexed_one_based__1" c_casadi__DMatrix__indexed_one_based__1
  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> CInt -> IO (Ptr DMatrix')
casadi__DMatrix__indexed_one_based__1
  :: DMatrix -> Int -> Int -> IO DMatrix
casadi__DMatrix__indexed_one_based__1 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__DMatrix__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
dmatrix_indexed_one_based__1 :: DMatrixClass a => a -> Int -> Int -> IO DMatrix
dmatrix_indexed_one_based__1 x = casadi__DMatrix__indexed_one_based__1 (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "casadi__DMatrix__indexed_one_based__2" c_casadi__DMatrix__indexed_one_based__2
  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr IMatrix' -> IO (Ptr DMatrix')
casadi__DMatrix__indexed_one_based__2
  :: DMatrix -> IMatrix -> IO DMatrix
casadi__DMatrix__indexed_one_based__2 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__DMatrix__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
dmatrix_indexed_one_based__2 :: DMatrixClass a => a -> IMatrix -> IO DMatrix
dmatrix_indexed_one_based__2 x = casadi__DMatrix__indexed_one_based__2 (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "casadi__DMatrix__indexed_one_based_assignment__0" c_casadi__DMatrix__indexed_one_based_assignment__0
  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> CDouble -> IO ()
casadi__DMatrix__indexed_one_based_assignment__0
  :: DMatrix -> Int -> Double -> IO ()
casadi__DMatrix__indexed_one_based_assignment__0 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__DMatrix__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
dmatrix_indexed_one_based_assignment__0 :: DMatrixClass a => a -> Int -> Double -> IO ()
dmatrix_indexed_one_based_assignment__0 x = casadi__DMatrix__indexed_one_based_assignment__0 (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "casadi__DMatrix__indexed_one_based_assignment__1" c_casadi__DMatrix__indexed_one_based_assignment__1
  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> CInt -> CDouble -> IO ()
casadi__DMatrix__indexed_one_based_assignment__1
  :: DMatrix -> Int -> Int -> Double -> IO ()
casadi__DMatrix__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__DMatrix__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
dmatrix_indexed_one_based_assignment__1 :: DMatrixClass a => a -> Int -> Int -> Double -> IO ()
dmatrix_indexed_one_based_assignment__1 x = casadi__DMatrix__indexed_one_based_assignment__1 (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "casadi__DMatrix__indexed_one_based_assignment__2" c_casadi__DMatrix__indexed_one_based_assignment__2
  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr IMatrix' -> Ptr DMatrix' -> IO ()
casadi__DMatrix__indexed_one_based_assignment__2
  :: DMatrix -> IMatrix -> DMatrix -> IO ()
casadi__DMatrix__indexed_one_based_assignment__2 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__DMatrix__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
dmatrix_indexed_one_based_assignment__2 :: DMatrixClass a => a -> IMatrix -> DMatrix -> IO ()
dmatrix_indexed_one_based_assignment__2 x = casadi__DMatrix__indexed_one_based_assignment__2 (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "casadi__DMatrix__indexed_zero_based__0" c_casadi__DMatrix__indexed_zero_based__0
  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> IO (Ptr DMatrix')
casadi__DMatrix__indexed_zero_based__0
  :: DMatrix -> Int -> IO DMatrix
casadi__DMatrix__indexed_zero_based__0 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__DMatrix__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
dmatrix_indexed_zero_based__0 :: DMatrixClass a => a -> Int -> IO DMatrix
dmatrix_indexed_zero_based__0 x = casadi__DMatrix__indexed_zero_based__0 (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "casadi__DMatrix__indexed_zero_based__1" c_casadi__DMatrix__indexed_zero_based__1
  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> CInt -> IO (Ptr DMatrix')
casadi__DMatrix__indexed_zero_based__1
  :: DMatrix -> Int -> Int -> IO DMatrix
casadi__DMatrix__indexed_zero_based__1 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__DMatrix__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
dmatrix_indexed_zero_based__1 :: DMatrixClass a => a -> Int -> Int -> IO DMatrix
dmatrix_indexed_zero_based__1 x = casadi__DMatrix__indexed_zero_based__1 (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "casadi__DMatrix__indexed_zero_based__2" c_casadi__DMatrix__indexed_zero_based__2
  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr IMatrix' -> IO (Ptr DMatrix')
casadi__DMatrix__indexed_zero_based__2
  :: DMatrix -> IMatrix -> IO DMatrix
casadi__DMatrix__indexed_zero_based__2 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__DMatrix__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
dmatrix_indexed_zero_based__2 :: DMatrixClass a => a -> IMatrix -> IO DMatrix
dmatrix_indexed_zero_based__2 x = casadi__DMatrix__indexed_zero_based__2 (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "casadi__DMatrix__indexed_zero_based_assignment__0" c_casadi__DMatrix__indexed_zero_based_assignment__0
  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> CDouble -> IO ()
casadi__DMatrix__indexed_zero_based_assignment__0
  :: DMatrix -> Int -> Double -> IO ()
casadi__DMatrix__indexed_zero_based_assignment__0 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__DMatrix__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
dmatrix_indexed_zero_based_assignment__0 :: DMatrixClass a => a -> Int -> Double -> IO ()
dmatrix_indexed_zero_based_assignment__0 x = casadi__DMatrix__indexed_zero_based_assignment__0 (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "casadi__DMatrix__indexed_zero_based_assignment__1" c_casadi__DMatrix__indexed_zero_based_assignment__1
  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> CInt -> CDouble -> IO ()
casadi__DMatrix__indexed_zero_based_assignment__1
  :: DMatrix -> Int -> Int -> Double -> IO ()
casadi__DMatrix__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__DMatrix__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
dmatrix_indexed_zero_based_assignment__1 :: DMatrixClass a => a -> Int -> Int -> Double -> IO ()
dmatrix_indexed_zero_based_assignment__1 x = casadi__DMatrix__indexed_zero_based_assignment__1 (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "casadi__DMatrix__indexed_zero_based_assignment__2" c_casadi__DMatrix__indexed_zero_based_assignment__2
  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr IMatrix' -> Ptr DMatrix' -> IO ()
casadi__DMatrix__indexed_zero_based_assignment__2
  :: DMatrix -> IMatrix -> DMatrix -> IO ()
casadi__DMatrix__indexed_zero_based_assignment__2 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__DMatrix__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
dmatrix_indexed_zero_based_assignment__2 :: DMatrixClass a => a -> IMatrix -> DMatrix -> IO ()
dmatrix_indexed_zero_based_assignment__2 x = casadi__DMatrix__indexed_zero_based_assignment__2 (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "casadi__DMatrix__inf__0" c_casadi__DMatrix__inf__0
  :: Ptr (Ptr StdString) -> IO (Ptr DMatrix')
casadi__DMatrix__inf__0
  :: IO DMatrix
casadi__DMatrix__inf__0  =

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


-- classy wrapper
dmatrix_inf__0 :: IO DMatrix
dmatrix_inf__0 = casadi__DMatrix__inf__0


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


-- classy wrapper
dmatrix_inf__1 :: Int -> IO DMatrix
dmatrix_inf__1 = casadi__DMatrix__inf__1


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


-- classy wrapper
dmatrix_inf__2 :: Int -> Int -> IO DMatrix
dmatrix_inf__2 = casadi__DMatrix__inf__2


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


-- classy wrapper
dmatrix_inf__3 :: Sparsity -> IO DMatrix
dmatrix_inf__3 = casadi__DMatrix__inf__3


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


-- classy wrapper
dmatrix_isConstant :: DMatrixClass a => a -> IO Bool
dmatrix_isConstant x = casadi__DMatrix__isConstant (castDMatrix x)


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


-- classy wrapper
dmatrix_isDense :: DMatrixClass a => a -> IO Bool
dmatrix_isDense x = casadi__DMatrix__isDense (castDMatrix x)


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


-- classy wrapper
dmatrix_isEmpty__0 :: DMatrixClass a => a -> IO Bool
dmatrix_isEmpty__0 x = casadi__DMatrix__isEmpty__0 (castDMatrix x)


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


-- classy wrapper
dmatrix_isEmpty__1 :: DMatrixClass a => a -> Bool -> IO Bool
dmatrix_isEmpty__1 x = casadi__DMatrix__isEmpty__1 (castDMatrix x)


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


-- classy wrapper
dmatrix_isEqual :: DMatrixClass a => a -> DMatrix -> IO Bool
dmatrix_isEqual x = casadi__DMatrix__isEqual (castDMatrix x)


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


-- classy wrapper
dmatrix_isIdentity :: DMatrixClass a => a -> IO Bool
dmatrix_isIdentity x = casadi__DMatrix__isIdentity (castDMatrix x)


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


-- classy wrapper
dmatrix_isInteger :: DMatrixClass a => a -> IO Bool
dmatrix_isInteger x = casadi__DMatrix__isInteger (castDMatrix x)


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


-- classy wrapper
dmatrix_isMinusOne :: DMatrixClass a => a -> IO Bool
dmatrix_isMinusOne x = casadi__DMatrix__isMinusOne (castDMatrix x)


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


-- classy wrapper
dmatrix_isOne :: DMatrixClass a => a -> IO Bool
dmatrix_isOne x = casadi__DMatrix__isOne (castDMatrix x)


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


-- classy wrapper
dmatrix_isRegular :: DMatrixClass a => a -> IO Bool
dmatrix_isRegular x = casadi__DMatrix__isRegular (castDMatrix x)


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


-- classy wrapper
dmatrix_isScalar__0 :: DMatrixClass a => a -> IO Bool
dmatrix_isScalar__0 x = casadi__DMatrix__isScalar__0 (castDMatrix x)


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


-- classy wrapper
dmatrix_isScalar__1 :: DMatrixClass a => a -> Bool -> IO Bool
dmatrix_isScalar__1 x = casadi__DMatrix__isScalar__1 (castDMatrix x)


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


-- classy wrapper
dmatrix_isSmooth :: DMatrixClass a => a -> IO Bool
dmatrix_isSmooth x = casadi__DMatrix__isSmooth (castDMatrix x)


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


-- classy wrapper
dmatrix_isSquare :: DMatrixClass a => a -> IO Bool
dmatrix_isSquare x = casadi__DMatrix__isSquare (castDMatrix x)


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


-- classy wrapper
dmatrix_isSymbolic :: DMatrixClass a => a -> IO Bool
dmatrix_isSymbolic x = casadi__DMatrix__isSymbolic (castDMatrix x)


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


-- classy wrapper
dmatrix_isSymbolicSparse :: DMatrixClass a => a -> IO Bool
dmatrix_isSymbolicSparse x = casadi__DMatrix__isSymbolicSparse (castDMatrix x)


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


-- classy wrapper
dmatrix_isTril :: DMatrixClass a => a -> IO Bool
dmatrix_isTril x = casadi__DMatrix__isTril (castDMatrix x)


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


-- classy wrapper
dmatrix_isTriu :: DMatrixClass a => a -> IO Bool
dmatrix_isTriu x = casadi__DMatrix__isTriu (castDMatrix x)


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


-- classy wrapper
dmatrix_isVector :: DMatrixClass a => a -> IO Bool
dmatrix_isVector x = casadi__DMatrix__isVector (castDMatrix x)


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


-- classy wrapper
dmatrix_isZero :: DMatrixClass a => a -> IO Bool
dmatrix_isZero x = casadi__DMatrix__isZero (castDMatrix x)


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


-- classy wrapper
dmatrix_log :: DMatrixClass a => a -> IO DMatrix
dmatrix_log x = casadi__DMatrix__log (castDMatrix x)


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


-- classy wrapper
dmatrix_log10 :: DMatrixClass a => a -> IO DMatrix
dmatrix_log10 x = casadi__DMatrix__log10 (castDMatrix x)


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


-- classy wrapper
dmatrix_logic_and :: DMatrixClass a => a -> DMatrix -> IO DMatrix
dmatrix_logic_and x = casadi__DMatrix__logic_and (castDMatrix x)


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


-- classy wrapper
dmatrix_logic_not :: DMatrixClass a => a -> IO DMatrix
dmatrix_logic_not x = casadi__DMatrix__logic_not (castDMatrix x)


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


-- classy wrapper
dmatrix_logic_or :: DMatrixClass a => a -> DMatrix -> IO DMatrix
dmatrix_logic_or x = casadi__DMatrix__logic_or (castDMatrix x)


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


-- classy wrapper
dmatrix_matrix_matrix :: Int -> DMatrix -> DMatrix -> IO DMatrix
dmatrix_matrix_matrix = casadi__DMatrix__matrix_matrix


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


-- classy wrapper
dmatrix_matrix_scalar :: Int -> DMatrix -> DMatrix -> IO DMatrix
dmatrix_matrix_scalar = casadi__DMatrix__matrix_scalar


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


-- classy wrapper
dmatrix_mul__0 :: DMatrixClass a => a -> DMatrix -> IO DMatrix
dmatrix_mul__0 x = casadi__DMatrix__mul__0 (castDMatrix x)


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


-- classy wrapper
dmatrix_mul__1 :: DMatrixClass a => a -> DMatrix -> Sparsity -> IO DMatrix
dmatrix_mul__1 x = casadi__DMatrix__mul__1 (castDMatrix x)


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


-- classy wrapper
dmatrix_mul_full__0 :: DMatrixClass a => a -> DMatrix -> IO DMatrix
dmatrix_mul_full__0 x = casadi__DMatrix__mul_full__0 (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "casadi__DMatrix__mul_full__1" c_casadi__DMatrix__mul_full__1
  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> Ptr Sparsity' -> IO (Ptr DMatrix')
casadi__DMatrix__mul_full__1
  :: DMatrix -> DMatrix -> Sparsity -> IO DMatrix
casadi__DMatrix__mul_full__1 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__DMatrix__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
dmatrix_mul_full__1 :: DMatrixClass a => a -> DMatrix -> Sparsity -> IO DMatrix
dmatrix_mul_full__1 x = casadi__DMatrix__mul_full__1 (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "casadi__DMatrix__mul_no_alloc_nn__0" c_casadi__DMatrix__mul_no_alloc_nn__0
  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr (StdVec CDouble) -> Ptr (StdVec CDouble) -> IO ()
casadi__DMatrix__mul_no_alloc_nn__0
  :: DMatrix -> Vector Double -> Vector Double -> IO ()
casadi__DMatrix__mul_no_alloc_nn__0 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__DMatrix__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
dmatrix_mul_no_alloc_nn__0 :: DMatrix -> Vector Double -> Vector Double -> IO ()
dmatrix_mul_no_alloc_nn__0 = casadi__DMatrix__mul_no_alloc_nn__0


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


-- classy wrapper
dmatrix_mul_no_alloc_nn__1 :: DMatrix -> DMatrix -> DMatrix -> Vector Double -> IO ()
dmatrix_mul_no_alloc_nn__1 = casadi__DMatrix__mul_no_alloc_nn__1


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


-- classy wrapper
dmatrix_mul_no_alloc_nn__2 :: DMatrix -> DMatrix -> DMatrix -> IO ()
dmatrix_mul_no_alloc_nn__2 = casadi__DMatrix__mul_no_alloc_nn__2


-- direct wrapper
foreign import ccall unsafe "casadi__DMatrix__mul_no_alloc_nt" c_casadi__DMatrix__mul_no_alloc_nt
  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> Ptr DMatrix' -> IO ()
casadi__DMatrix__mul_no_alloc_nt
  :: DMatrix -> DMatrix -> DMatrix -> IO ()
casadi__DMatrix__mul_no_alloc_nt x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__DMatrix__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
dmatrix_mul_no_alloc_nt :: DMatrix -> DMatrix -> DMatrix -> IO ()
dmatrix_mul_no_alloc_nt = casadi__DMatrix__mul_no_alloc_nt


-- direct wrapper
foreign import ccall unsafe "casadi__DMatrix__mul_no_alloc_tn__0" c_casadi__DMatrix__mul_no_alloc_tn__0
  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr (StdVec CDouble) -> Ptr (StdVec CDouble) -> IO ()
casadi__DMatrix__mul_no_alloc_tn__0
  :: DMatrix -> Vector Double -> Vector Double -> IO ()
casadi__DMatrix__mul_no_alloc_tn__0 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__DMatrix__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
dmatrix_mul_no_alloc_tn__0 :: DMatrix -> Vector Double -> Vector Double -> IO ()
dmatrix_mul_no_alloc_tn__0 = casadi__DMatrix__mul_no_alloc_tn__0


-- direct wrapper
foreign import ccall unsafe "casadi__DMatrix__mul_no_alloc_tn__1" c_casadi__DMatrix__mul_no_alloc_tn__1
  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> Ptr DMatrix' -> IO ()
casadi__DMatrix__mul_no_alloc_tn__1
  :: DMatrix -> DMatrix -> DMatrix -> IO ()
casadi__DMatrix__mul_no_alloc_tn__1 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__DMatrix__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
dmatrix_mul_no_alloc_tn__1 :: DMatrix -> DMatrix -> DMatrix -> IO ()
dmatrix_mul_no_alloc_tn__1 = casadi__DMatrix__mul_no_alloc_tn__1


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


-- classy wrapper
dmatrix_mul_smart :: DMatrixClass a => a -> DMatrix -> Sparsity -> IO DMatrix
dmatrix_mul_smart x = casadi__DMatrix__mul_smart (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "casadi__DMatrix__nan__0" c_casadi__DMatrix__nan__0
  :: Ptr (Ptr StdString) -> IO (Ptr DMatrix')
casadi__DMatrix__nan__0
  :: IO DMatrix
casadi__DMatrix__nan__0  =

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


-- classy wrapper
dmatrix_nan__0 :: IO DMatrix
dmatrix_nan__0 = casadi__DMatrix__nan__0


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


-- classy wrapper
dmatrix_nan__1 :: Int -> IO DMatrix
dmatrix_nan__1 = casadi__DMatrix__nan__1


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


-- classy wrapper
dmatrix_nan__2 :: Int -> Int -> IO DMatrix
dmatrix_nan__2 = casadi__DMatrix__nan__2


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


-- classy wrapper
dmatrix_nan__3 :: Sparsity -> IO DMatrix
dmatrix_nan__3 = casadi__DMatrix__nan__3


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


-- classy wrapper
dmatrix_numel :: DMatrixClass a => a -> IO Int
dmatrix_numel x = casadi__DMatrix__numel (castDMatrix x)


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


-- classy wrapper
dmatrix_nz_indexed :: DMatrixClass a => a -> Slice -> IO DMatrix
dmatrix_nz_indexed x = casadi__DMatrix__nz_indexed (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "casadi__DMatrix__nz_indexed_assignment" c_casadi__DMatrix__nz_indexed_assignment
  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr Slice' -> Ptr DMatrix' -> IO ()
casadi__DMatrix__nz_indexed_assignment
  :: DMatrix -> Slice -> DMatrix -> IO ()
casadi__DMatrix__nz_indexed_assignment x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__DMatrix__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
dmatrix_nz_indexed_assignment :: DMatrixClass a => a -> Slice -> DMatrix -> IO ()
dmatrix_nz_indexed_assignment x = casadi__DMatrix__nz_indexed_assignment (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "casadi__DMatrix__nz_indexed_one_based__0" c_casadi__DMatrix__nz_indexed_one_based__0
  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr IMatrix' -> IO (Ptr DMatrix')
casadi__DMatrix__nz_indexed_one_based__0
  :: DMatrix -> IMatrix -> IO DMatrix
casadi__DMatrix__nz_indexed_one_based__0 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__DMatrix__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
dmatrix_nz_indexed_one_based__0 :: DMatrixClass a => a -> IMatrix -> IO DMatrix
dmatrix_nz_indexed_one_based__0 x = casadi__DMatrix__nz_indexed_one_based__0 (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "casadi__DMatrix__nz_indexed_one_based__1" c_casadi__DMatrix__nz_indexed_one_based__1
  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> IO (Ptr DMatrix')
casadi__DMatrix__nz_indexed_one_based__1
  :: DMatrix -> Int -> IO DMatrix
casadi__DMatrix__nz_indexed_one_based__1 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__DMatrix__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
dmatrix_nz_indexed_one_based__1 :: DMatrixClass a => a -> Int -> IO DMatrix
dmatrix_nz_indexed_one_based__1 x = casadi__DMatrix__nz_indexed_one_based__1 (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "casadi__DMatrix__nz_indexed_one_based_assignment__0" c_casadi__DMatrix__nz_indexed_one_based_assignment__0
  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr IMatrix' -> Ptr DMatrix' -> IO ()
casadi__DMatrix__nz_indexed_one_based_assignment__0
  :: DMatrix -> IMatrix -> DMatrix -> IO ()
casadi__DMatrix__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__DMatrix__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
dmatrix_nz_indexed_one_based_assignment__0 :: DMatrixClass a => a -> IMatrix -> DMatrix -> IO ()
dmatrix_nz_indexed_one_based_assignment__0 x = casadi__DMatrix__nz_indexed_one_based_assignment__0 (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "casadi__DMatrix__nz_indexed_one_based_assignment__1" c_casadi__DMatrix__nz_indexed_one_based_assignment__1
  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> CDouble -> IO ()
casadi__DMatrix__nz_indexed_one_based_assignment__1
  :: DMatrix -> Int -> Double -> IO ()
casadi__DMatrix__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__DMatrix__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
dmatrix_nz_indexed_one_based_assignment__1 :: DMatrixClass a => a -> Int -> Double -> IO ()
dmatrix_nz_indexed_one_based_assignment__1 x = casadi__DMatrix__nz_indexed_one_based_assignment__1 (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "casadi__DMatrix__nz_indexed_zero_based__0" c_casadi__DMatrix__nz_indexed_zero_based__0
  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr IMatrix' -> IO (Ptr DMatrix')
casadi__DMatrix__nz_indexed_zero_based__0
  :: DMatrix -> IMatrix -> IO DMatrix
casadi__DMatrix__nz_indexed_zero_based__0 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__DMatrix__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
dmatrix_nz_indexed_zero_based__0 :: DMatrixClass a => a -> IMatrix -> IO DMatrix
dmatrix_nz_indexed_zero_based__0 x = casadi__DMatrix__nz_indexed_zero_based__0 (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "casadi__DMatrix__nz_indexed_zero_based__1" c_casadi__DMatrix__nz_indexed_zero_based__1
  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> IO (Ptr DMatrix')
casadi__DMatrix__nz_indexed_zero_based__1
  :: DMatrix -> Int -> IO DMatrix
casadi__DMatrix__nz_indexed_zero_based__1 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__DMatrix__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
dmatrix_nz_indexed_zero_based__1 :: DMatrixClass a => a -> Int -> IO DMatrix
dmatrix_nz_indexed_zero_based__1 x = casadi__DMatrix__nz_indexed_zero_based__1 (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "casadi__DMatrix__nz_indexed_zero_based_assignment__0" c_casadi__DMatrix__nz_indexed_zero_based_assignment__0
  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr IMatrix' -> Ptr DMatrix' -> IO ()
casadi__DMatrix__nz_indexed_zero_based_assignment__0
  :: DMatrix -> IMatrix -> DMatrix -> IO ()
casadi__DMatrix__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__DMatrix__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
dmatrix_nz_indexed_zero_based_assignment__0 :: DMatrixClass a => a -> IMatrix -> DMatrix -> IO ()
dmatrix_nz_indexed_zero_based_assignment__0 x = casadi__DMatrix__nz_indexed_zero_based_assignment__0 (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "casadi__DMatrix__nz_indexed_zero_based_assignment__1" c_casadi__DMatrix__nz_indexed_zero_based_assignment__1
  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> CDouble -> IO ()
casadi__DMatrix__nz_indexed_zero_based_assignment__1
  :: DMatrix -> Int -> Double -> IO ()
casadi__DMatrix__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__DMatrix__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
dmatrix_nz_indexed_zero_based_assignment__1 :: DMatrixClass a => a -> Int -> Double -> IO ()
dmatrix_nz_indexed_zero_based_assignment__1 x = casadi__DMatrix__nz_indexed_zero_based_assignment__1 (castDMatrix x)


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


-- classy wrapper
dmatrix_ones__0 :: Sparsity -> IO DMatrix
dmatrix_ones__0 = casadi__DMatrix__ones__0


-- direct wrapper
foreign import ccall unsafe "casadi__DMatrix__ones__1" c_casadi__DMatrix__ones__1
  :: Ptr (Ptr StdString) -> IO (Ptr DMatrix')
casadi__DMatrix__ones__1
  :: IO DMatrix
casadi__DMatrix__ones__1  =

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


-- classy wrapper
dmatrix_ones__1 :: IO DMatrix
dmatrix_ones__1 = casadi__DMatrix__ones__1


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


-- classy wrapper
dmatrix_ones__2 :: Int -> IO DMatrix
dmatrix_ones__2 = casadi__DMatrix__ones__2


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


-- classy wrapper
dmatrix_ones__3 :: Int -> Int -> IO DMatrix
dmatrix_ones__3 = casadi__DMatrix__ones__3


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


-- classy wrapper
dmatrix_printDense :: DMatrixClass a => a -> IO ()
dmatrix_printDense x = casadi__DMatrix__printDense (castDMatrix x)


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


-- classy wrapper
dmatrix_printScalar :: DMatrixClass a => a -> IO ()
dmatrix_printScalar x = casadi__DMatrix__printScalar (castDMatrix x)


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


-- classy wrapper
dmatrix_printSparse :: DMatrixClass a => a -> IO ()
dmatrix_printSparse x = casadi__DMatrix__printSparse (castDMatrix x)


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


-- classy wrapper
dmatrix_printVector :: DMatrixClass a => a -> IO ()
dmatrix_printVector x = casadi__DMatrix__printVector (castDMatrix x)


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


-- classy wrapper
dmatrix_printme :: DMatrixClass a => a -> DMatrix -> IO DMatrix
dmatrix_printme x = casadi__DMatrix__printme (castDMatrix x)


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


-- classy wrapper
dmatrix_quad_form :: Vector Double -> DMatrix -> IO Double
dmatrix_quad_form = casadi__DMatrix__quad_form


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


-- classy wrapper
dmatrix_remove :: DMatrixClass a => a -> Vector Int -> Vector Int -> IO ()
dmatrix_remove x = casadi__DMatrix__remove (castDMatrix x)


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


-- classy wrapper
dmatrix_repmat__0 :: DMatrix -> Int -> IO DMatrix
dmatrix_repmat__0 = casadi__DMatrix__repmat__0


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


-- classy wrapper
dmatrix_repmat__1 :: DMatrix -> Int -> Int -> IO DMatrix
dmatrix_repmat__1 = casadi__DMatrix__repmat__1


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


-- classy wrapper
dmatrix_repmat__2 :: DMatrix -> Sparsity -> IO DMatrix
dmatrix_repmat__2 = casadi__DMatrix__repmat__2


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


-- classy wrapper
dmatrix_repmat__3 :: Double -> Sparsity -> IO DMatrix
dmatrix_repmat__3 = casadi__DMatrix__repmat__3


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


-- classy wrapper
dmatrix_reserve__0 :: DMatrixClass a => a -> Int -> Int -> IO ()
dmatrix_reserve__0 x = casadi__DMatrix__reserve__0 (castDMatrix x)


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


-- classy wrapper
dmatrix_reserve__1 :: DMatrixClass a => a -> Int -> IO ()
dmatrix_reserve__1 x = casadi__DMatrix__reserve__1 (castDMatrix x)


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


-- classy wrapper
dmatrix_resize :: DMatrixClass a => a -> Int -> Int -> IO ()
dmatrix_resize x = casadi__DMatrix__resize (castDMatrix x)


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


-- classy wrapper
dmatrix_row__0 :: DMatrixClass a => a -> Int -> IO Int
dmatrix_row__0 x = casadi__DMatrix__row__0 (castDMatrix x)


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


-- classy wrapper
dmatrix_row__1 :: DMatrixClass a => a -> IO (Vector Int)
dmatrix_row__1 x = casadi__DMatrix__row__1 (castDMatrix x)


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


-- classy wrapper
dmatrix_sanityCheck__0 :: DMatrixClass a => a -> IO ()
dmatrix_sanityCheck__0 x = casadi__DMatrix__sanityCheck__0 (castDMatrix x)


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


-- classy wrapper
dmatrix_sanityCheck__1 :: DMatrixClass a => a -> Bool -> IO ()
dmatrix_sanityCheck__1 x = casadi__DMatrix__sanityCheck__1 (castDMatrix x)


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


-- classy wrapper
dmatrix_scalar_matrix :: Int -> DMatrix -> DMatrix -> IO DMatrix
dmatrix_scalar_matrix = casadi__DMatrix__scalar_matrix


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


-- classy wrapper
dmatrix_set__0 :: DMatrixClass a => a -> DMatrix -> IO ()
dmatrix_set__0 x = casadi__DMatrix__set__0 (castDMatrix x)


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


-- classy wrapper
dmatrix_set__1 :: DMatrixClass a => a -> DMatrix -> SparsityType -> IO ()
dmatrix_set__1 x = casadi__DMatrix__set__1 (castDMatrix x)


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


-- classy wrapper
dmatrix_set__2 :: DMatrixClass a => a -> Vector Double -> IO ()
dmatrix_set__2 x = casadi__DMatrix__set__2 (castDMatrix x)


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


-- classy wrapper
dmatrix_set__3 :: DMatrixClass a => a -> Vector Double -> SparsityType -> IO ()
dmatrix_set__3 x = casadi__DMatrix__set__3 (castDMatrix x)


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


-- classy wrapper
dmatrix_set__4 :: DMatrixClass a => a -> Double -> IO ()
dmatrix_set__4 x = casadi__DMatrix__set__4 (castDMatrix x)


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


-- classy wrapper
dmatrix_set__5 :: DMatrixClass a => a -> Double -> SparsityType -> IO ()
dmatrix_set__5 x = casadi__DMatrix__set__5 (castDMatrix x)


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


-- classy wrapper
dmatrix_setAll :: DMatrixClass a => a -> Double -> IO ()
dmatrix_setAll x = casadi__DMatrix__setAll (castDMatrix x)


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

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


-- classy wrapper
dmatrix_setEqualityCheckingDepth__0 :: IO ()
dmatrix_setEqualityCheckingDepth__0 = casadi__DMatrix__setEqualityCheckingDepth__0


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


-- classy wrapper
dmatrix_setEqualityCheckingDepth__1 :: Int -> IO ()
dmatrix_setEqualityCheckingDepth__1 = casadi__DMatrix__setEqualityCheckingDepth__1


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

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


-- classy wrapper
dmatrix_setMaxNumCallsInPrint__0 :: IO ()
dmatrix_setMaxNumCallsInPrint__0 = casadi__DMatrix__setMaxNumCallsInPrint__0


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


-- classy wrapper
dmatrix_setMaxNumCallsInPrint__1 :: Int -> IO ()
dmatrix_setMaxNumCallsInPrint__1 = casadi__DMatrix__setMaxNumCallsInPrint__1


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


-- classy wrapper
dmatrix_setNZ__0 :: DMatrixClass a => a -> IMatrix -> DMatrix -> IO ()
dmatrix_setNZ__0 x = casadi__DMatrix__setNZ__0 (castDMatrix x)


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


-- classy wrapper
dmatrix_setNZ__1 :: DMatrixClass a => a -> Slice -> DMatrix -> IO ()
dmatrix_setNZ__1 x = casadi__DMatrix__setNZ__1 (castDMatrix x)


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


-- classy wrapper
dmatrix_setNZ__2 :: DMatrixClass a => a -> Vector Int -> DMatrix -> IO ()
dmatrix_setNZ__2 x = casadi__DMatrix__setNZ__2 (castDMatrix x)


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


-- classy wrapper
dmatrix_setNZ__3 :: DMatrixClass a => a -> Int -> DMatrix -> IO ()
dmatrix_setNZ__3 x = casadi__DMatrix__setNZ__3 (castDMatrix x)


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


-- classy wrapper
dmatrix_setPrecision :: Int -> IO ()
dmatrix_setPrecision = casadi__DMatrix__setPrecision


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


-- classy wrapper
dmatrix_setScientific :: Bool -> IO ()
dmatrix_setScientific = casadi__DMatrix__setScientific


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


-- classy wrapper
dmatrix_setSparse__0 :: DMatrixClass a => a -> Sparsity -> IO DMatrix
dmatrix_setSparse__0 x = casadi__DMatrix__setSparse__0 (castDMatrix x)


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


-- classy wrapper
dmatrix_setSparse__1 :: DMatrixClass a => a -> Sparsity -> Bool -> IO DMatrix
dmatrix_setSparse__1 x = casadi__DMatrix__setSparse__1 (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "casadi__DMatrix__setSub__0" c_casadi__DMatrix__setSub__0
  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> Ptr Sparsity' -> CInt -> IO ()
casadi__DMatrix__setSub__0
  :: DMatrix -> DMatrix -> Sparsity -> Int -> IO ()
casadi__DMatrix__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__DMatrix__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
dmatrix_setSub__0 :: DMatrixClass a => a -> DMatrix -> Sparsity -> Int -> IO ()
dmatrix_setSub__0 x = casadi__DMatrix__setSub__0 (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "casadi__DMatrix__setSub__1" c_casadi__DMatrix__setSub__1
  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> CInt -> Ptr Slice' -> IO ()
casadi__DMatrix__setSub__1
  :: DMatrix -> DMatrix -> Int -> Slice -> IO ()
casadi__DMatrix__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__DMatrix__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
dmatrix_setSub__1 :: DMatrixClass a => a -> DMatrix -> Int -> Slice -> IO ()
dmatrix_setSub__1 x = casadi__DMatrix__setSub__1 (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "casadi__DMatrix__setSub__2" c_casadi__DMatrix__setSub__2
  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> Ptr Slice' -> CInt -> IO ()
casadi__DMatrix__setSub__2
  :: DMatrix -> DMatrix -> Slice -> Int -> IO ()
casadi__DMatrix__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__DMatrix__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
dmatrix_setSub__2 :: DMatrixClass a => a -> DMatrix -> Slice -> Int -> IO ()
dmatrix_setSub__2 x = casadi__DMatrix__setSub__2 (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "casadi__DMatrix__setSub__3" c_casadi__DMatrix__setSub__3
  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> IO ()
casadi__DMatrix__setSub__3
  :: DMatrix -> DMatrix -> IMatrix -> IMatrix -> IO ()
casadi__DMatrix__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__DMatrix__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
dmatrix_setSub__3 :: DMatrixClass a => a -> DMatrix -> IMatrix -> IMatrix -> IO ()
dmatrix_setSub__3 x = casadi__DMatrix__setSub__3 (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "casadi__DMatrix__setSub__4" c_casadi__DMatrix__setSub__4
  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> Ptr Slice' -> Ptr IMatrix' -> IO ()
casadi__DMatrix__setSub__4
  :: DMatrix -> DMatrix -> Slice -> IMatrix -> IO ()
casadi__DMatrix__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__DMatrix__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
dmatrix_setSub__4 :: DMatrixClass a => a -> DMatrix -> Slice -> IMatrix -> IO ()
dmatrix_setSub__4 x = casadi__DMatrix__setSub__4 (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "casadi__DMatrix__setSub__5" c_casadi__DMatrix__setSub__5
  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> Ptr IMatrix' -> Ptr Slice' -> IO ()
casadi__DMatrix__setSub__5
  :: DMatrix -> DMatrix -> IMatrix -> Slice -> IO ()
casadi__DMatrix__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__DMatrix__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
dmatrix_setSub__5 :: DMatrixClass a => a -> DMatrix -> IMatrix -> Slice -> IO ()
dmatrix_setSub__5 x = casadi__DMatrix__setSub__5 (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "casadi__DMatrix__setSub__6" c_casadi__DMatrix__setSub__6
  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> CInt -> Ptr IMatrix' -> IO ()
casadi__DMatrix__setSub__6
  :: DMatrix -> DMatrix -> Int -> IMatrix -> IO ()
casadi__DMatrix__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__DMatrix__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
dmatrix_setSub__6 :: DMatrixClass a => a -> DMatrix -> Int -> IMatrix -> IO ()
dmatrix_setSub__6 x = casadi__DMatrix__setSub__6 (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "casadi__DMatrix__setSub__7" c_casadi__DMatrix__setSub__7
  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> Ptr (StdVec CInt) -> Ptr IMatrix' -> IO ()
casadi__DMatrix__setSub__7
  :: DMatrix -> DMatrix -> Vector Int -> IMatrix -> IO ()
casadi__DMatrix__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__DMatrix__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
dmatrix_setSub__7 :: DMatrixClass a => a -> DMatrix -> Vector Int -> IMatrix -> IO ()
dmatrix_setSub__7 x = casadi__DMatrix__setSub__7 (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "casadi__DMatrix__setSub__8" c_casadi__DMatrix__setSub__8
  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> Ptr IMatrix' -> CInt -> IO ()
casadi__DMatrix__setSub__8
  :: DMatrix -> DMatrix -> IMatrix -> Int -> IO ()
casadi__DMatrix__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__DMatrix__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
dmatrix_setSub__8 :: DMatrixClass a => a -> DMatrix -> IMatrix -> Int -> IO ()
dmatrix_setSub__8 x = casadi__DMatrix__setSub__8 (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "casadi__DMatrix__setSub__9" c_casadi__DMatrix__setSub__9
  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> Ptr IMatrix' -> Ptr (StdVec CInt) -> IO ()
casadi__DMatrix__setSub__9
  :: DMatrix -> DMatrix -> IMatrix -> Vector Int -> IO ()
casadi__DMatrix__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__DMatrix__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
dmatrix_setSub__9 :: DMatrixClass a => a -> DMatrix -> IMatrix -> Vector Int -> IO ()
dmatrix_setSub__9 x = casadi__DMatrix__setSub__9 (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "casadi__DMatrix__setSub__10" c_casadi__DMatrix__setSub__10
  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> Ptr Slice' -> Ptr Slice' -> IO ()
casadi__DMatrix__setSub__10
  :: DMatrix -> DMatrix -> Slice -> Slice -> IO ()
casadi__DMatrix__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__DMatrix__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
dmatrix_setSub__10 :: DMatrixClass a => a -> DMatrix -> Slice -> Slice -> IO ()
dmatrix_setSub__10 x = casadi__DMatrix__setSub__10 (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "casadi__DMatrix__setSub__11" c_casadi__DMatrix__setSub__11
  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> Ptr (StdVec CInt) -> Ptr Slice' -> IO ()
casadi__DMatrix__setSub__11
  :: DMatrix -> DMatrix -> Vector Int -> Slice -> IO ()
casadi__DMatrix__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__DMatrix__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
dmatrix_setSub__11 :: DMatrixClass a => a -> DMatrix -> Vector Int -> Slice -> IO ()
dmatrix_setSub__11 x = casadi__DMatrix__setSub__11 (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "casadi__DMatrix__setSub__12" c_casadi__DMatrix__setSub__12
  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> Ptr Slice' -> Ptr (StdVec CInt) -> IO ()
casadi__DMatrix__setSub__12
  :: DMatrix -> DMatrix -> Slice -> Vector Int -> IO ()
casadi__DMatrix__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__DMatrix__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
dmatrix_setSub__12 :: DMatrixClass a => a -> DMatrix -> Slice -> Vector Int -> IO ()
dmatrix_setSub__12 x = casadi__DMatrix__setSub__12 (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "casadi__DMatrix__setSub__13" c_casadi__DMatrix__setSub__13
  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO ()
casadi__DMatrix__setSub__13
  :: DMatrix -> DMatrix -> Vector Int -> Vector Int -> IO ()
casadi__DMatrix__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__DMatrix__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
dmatrix_setSub__13 :: DMatrixClass a => a -> DMatrix -> Vector Int -> Vector Int -> IO ()
dmatrix_setSub__13 x = casadi__DMatrix__setSub__13 (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "casadi__DMatrix__setSub__14" c_casadi__DMatrix__setSub__14
  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> CInt -> Ptr (StdVec CInt) -> IO ()
casadi__DMatrix__setSub__14
  :: DMatrix -> DMatrix -> Int -> Vector Int -> IO ()
casadi__DMatrix__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__DMatrix__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
dmatrix_setSub__14 :: DMatrixClass a => a -> DMatrix -> Int -> Vector Int -> IO ()
dmatrix_setSub__14 x = casadi__DMatrix__setSub__14 (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "casadi__DMatrix__setSub__15" c_casadi__DMatrix__setSub__15
  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> Ptr (StdVec CInt) -> CInt -> IO ()
casadi__DMatrix__setSub__15
  :: DMatrix -> DMatrix -> Vector Int -> Int -> IO ()
casadi__DMatrix__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__DMatrix__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
dmatrix_setSub__15 :: DMatrixClass a => a -> DMatrix -> Vector Int -> Int -> IO ()
dmatrix_setSub__15 x = casadi__DMatrix__setSub__15 (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "casadi__DMatrix__setSub__16" c_casadi__DMatrix__setSub__16
  :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> CInt -> CInt -> IO ()
casadi__DMatrix__setSub__16
  :: DMatrix -> DMatrix -> Int -> Int -> IO ()
casadi__DMatrix__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__DMatrix__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
dmatrix_setSub__16 :: DMatrixClass a => a -> DMatrix -> Int -> Int -> IO ()
dmatrix_setSub__16 x = casadi__DMatrix__setSub__16 (castDMatrix x)


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


-- classy wrapper
dmatrix_setWidth :: Int -> IO ()
dmatrix_setWidth = casadi__DMatrix__setWidth


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


-- classy wrapper
dmatrix_setZero :: DMatrixClass a => a -> IO ()
dmatrix_setZero x = casadi__DMatrix__setZero (castDMatrix x)


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


-- classy wrapper
dmatrix_sign :: DMatrixClass a => a -> IO DMatrix
dmatrix_sign x = casadi__DMatrix__sign (castDMatrix x)


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


-- classy wrapper
dmatrix_sin :: DMatrixClass a => a -> IO DMatrix
dmatrix_sin x = casadi__DMatrix__sin (castDMatrix x)


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


-- classy wrapper
dmatrix_sinh :: DMatrixClass a => a -> IO DMatrix
dmatrix_sinh x = casadi__DMatrix__sinh (castDMatrix x)


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


-- classy wrapper
dmatrix_size__0 :: DMatrixClass a => a -> SparsityType -> IO Int
dmatrix_size__0 x = casadi__DMatrix__size__0 (castDMatrix x)


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


-- classy wrapper
dmatrix_size__1 :: DMatrixClass a => a -> IO Int
dmatrix_size__1 x = casadi__DMatrix__size__1 (castDMatrix x)


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


-- classy wrapper
dmatrix_size1 :: DMatrixClass a => a -> IO Int
dmatrix_size1 x = casadi__DMatrix__size1 (castDMatrix x)


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


-- classy wrapper
dmatrix_size2 :: DMatrixClass a => a -> IO Int
dmatrix_size2 x = casadi__DMatrix__size2 (castDMatrix x)


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


-- classy wrapper
dmatrix_sizeD :: DMatrixClass a => a -> IO Int
dmatrix_sizeD x = casadi__DMatrix__sizeD (castDMatrix x)


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


-- classy wrapper
dmatrix_sizeL :: DMatrixClass a => a -> IO Int
dmatrix_sizeL x = casadi__DMatrix__sizeL (castDMatrix x)


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


-- classy wrapper
dmatrix_sizeU :: DMatrixClass a => a -> IO Int
dmatrix_sizeU x = casadi__DMatrix__sizeU (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "casadi__DMatrix__sparse__0" c_casadi__DMatrix__sparse__0
  :: Ptr (Ptr StdString) -> IO (Ptr DMatrix')
casadi__DMatrix__sparse__0
  :: IO DMatrix
casadi__DMatrix__sparse__0  =

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


-- classy wrapper
dmatrix_sparse__0 :: IO DMatrix
dmatrix_sparse__0 = casadi__DMatrix__sparse__0


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


-- classy wrapper
dmatrix_sparse__1 :: Int -> IO DMatrix
dmatrix_sparse__1 = casadi__DMatrix__sparse__1


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


-- classy wrapper
dmatrix_sparse__2 :: Int -> Int -> IO DMatrix
dmatrix_sparse__2 = casadi__DMatrix__sparse__2


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


-- classy wrapper
dmatrix_sparsify__0 :: DMatrixClass a => a -> IO ()
dmatrix_sparsify__0 x = casadi__DMatrix__sparsify__0 (castDMatrix x)


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


-- classy wrapper
dmatrix_sparsify__1 :: DMatrixClass a => a -> Double -> IO ()
dmatrix_sparsify__1 x = casadi__DMatrix__sparsify__1 (castDMatrix x)


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


-- classy wrapper
dmatrix_sparsity__0 :: DMatrixClass a => a -> IO Sparsity
dmatrix_sparsity__0 x = casadi__DMatrix__sparsity__0 (castDMatrix x)


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


-- classy wrapper
dmatrix_sparsity__1 :: DMatrixClass a => a -> IO Sparsity
dmatrix_sparsity__1 x = casadi__DMatrix__sparsity__1 (castDMatrix x)


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


-- classy wrapper
dmatrix_sparsityRef__0 :: DMatrixClass a => a -> IO Sparsity
dmatrix_sparsityRef__0 x = casadi__DMatrix__sparsityRef__0 (castDMatrix x)


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


-- classy wrapper
dmatrix_sparsityRef__1 :: DMatrixClass a => a -> IO Sparsity
dmatrix_sparsityRef__1 x = casadi__DMatrix__sparsityRef__1 (castDMatrix x)


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


-- classy wrapper
dmatrix_sqrt :: DMatrixClass a => a -> IO DMatrix
dmatrix_sqrt x = casadi__DMatrix__sqrt (castDMatrix x)


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


-- classy wrapper
dmatrix_sub__0 :: DMatrixClass a => a -> Sparsity -> IO DMatrix
dmatrix_sub__0 x = casadi__DMatrix__sub__0 (castDMatrix x)


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


-- classy wrapper
dmatrix_sub__1 :: DMatrixClass a => a -> Sparsity -> Int -> IO DMatrix
dmatrix_sub__1 x = casadi__DMatrix__sub__1 (castDMatrix x)


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


-- classy wrapper
dmatrix_sub__2 :: DMatrixClass a => a -> IMatrix -> IMatrix -> IO DMatrix
dmatrix_sub__2 x = casadi__DMatrix__sub__2 (castDMatrix x)


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


-- classy wrapper
dmatrix_sub__3 :: DMatrixClass a => a -> Slice -> IMatrix -> IO DMatrix
dmatrix_sub__3 x = casadi__DMatrix__sub__3 (castDMatrix x)


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


-- classy wrapper
dmatrix_sub__4 :: DMatrixClass a => a -> IMatrix -> Slice -> IO DMatrix
dmatrix_sub__4 x = casadi__DMatrix__sub__4 (castDMatrix x)


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


-- classy wrapper
dmatrix_sub__5 :: DMatrixClass a => a -> Int -> IMatrix -> IO DMatrix
dmatrix_sub__5 x = casadi__DMatrix__sub__5 (castDMatrix x)


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


-- classy wrapper
dmatrix_sub__6 :: DMatrixClass a => a -> Vector Int -> IMatrix -> IO DMatrix
dmatrix_sub__6 x = casadi__DMatrix__sub__6 (castDMatrix x)


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


-- classy wrapper
dmatrix_sub__7 :: DMatrixClass a => a -> IMatrix -> Int -> IO DMatrix
dmatrix_sub__7 x = casadi__DMatrix__sub__7 (castDMatrix x)


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


-- classy wrapper
dmatrix_sub__8 :: DMatrixClass a => a -> IMatrix -> Vector Int -> IO DMatrix
dmatrix_sub__8 x = casadi__DMatrix__sub__8 (castDMatrix x)


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


-- classy wrapper
dmatrix_sub__9 :: DMatrixClass a => a -> Int -> Slice -> IO DMatrix
dmatrix_sub__9 x = casadi__DMatrix__sub__9 (castDMatrix x)


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


-- classy wrapper
dmatrix_sub__10 :: DMatrixClass a => a -> Slice -> Int -> IO DMatrix
dmatrix_sub__10 x = casadi__DMatrix__sub__10 (castDMatrix x)


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


-- classy wrapper
dmatrix_sub__11 :: DMatrixClass a => a -> Slice -> Slice -> IO DMatrix
dmatrix_sub__11 x = casadi__DMatrix__sub__11 (castDMatrix x)


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


-- classy wrapper
dmatrix_sub__12 :: DMatrixClass a => a -> Vector Int -> Slice -> IO DMatrix
dmatrix_sub__12 x = casadi__DMatrix__sub__12 (castDMatrix x)


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


-- classy wrapper
dmatrix_sub__13 :: DMatrixClass a => a -> Slice -> Vector Int -> IO DMatrix
dmatrix_sub__13 x = casadi__DMatrix__sub__13 (castDMatrix x)


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


-- classy wrapper
dmatrix_sub__14 :: DMatrixClass a => a -> Vector Int -> Vector Int -> IO DMatrix
dmatrix_sub__14 x = casadi__DMatrix__sub__14 (castDMatrix x)


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


-- classy wrapper
dmatrix_sub__15 :: DMatrixClass a => a -> Int -> Vector Int -> IO DMatrix
dmatrix_sub__15 x = casadi__DMatrix__sub__15 (castDMatrix x)


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


-- classy wrapper
dmatrix_sub__16 :: DMatrixClass a => a -> Vector Int -> Int -> IO DMatrix
dmatrix_sub__16 x = casadi__DMatrix__sub__16 (castDMatrix x)


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


-- classy wrapper
dmatrix_sub__17 :: DMatrixClass a => a -> Int -> Int -> IO DMatrix
dmatrix_sub__17 x = casadi__DMatrix__sub__17 (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "casadi__DMatrix__sym__0" c_casadi__DMatrix__sym__0
  :: Ptr (Ptr StdString) -> Ptr StdString -> CInt -> CInt -> CInt -> CInt -> IO (Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))))
casadi__DMatrix__sym__0
  :: String -> Int -> Int -> Int -> Int -> IO (Vector (Vector DMatrix))
casadi__DMatrix__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__DMatrix__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
dmatrix_sym__0 :: String -> Int -> Int -> Int -> Int -> IO (Vector (Vector DMatrix))
dmatrix_sym__0 = casadi__DMatrix__sym__0


-- direct wrapper
foreign import ccall unsafe "casadi__DMatrix__sym__1" c_casadi__DMatrix__sym__1
  :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> CInt -> CInt -> IO (Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))))
casadi__DMatrix__sym__1
  :: String -> Sparsity -> Int -> Int -> IO (Vector (Vector DMatrix))
casadi__DMatrix__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__DMatrix__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
dmatrix_sym__1 :: String -> Sparsity -> Int -> Int -> IO (Vector (Vector DMatrix))
dmatrix_sym__1 = casadi__DMatrix__sym__1


-- direct wrapper
foreign import ccall unsafe "casadi__DMatrix__sym__2" c_casadi__DMatrix__sym__2
  :: Ptr (Ptr StdString) -> Ptr StdString -> CInt -> CInt -> CInt -> IO (Ptr (StdVec (Ptr DMatrix')))
casadi__DMatrix__sym__2
  :: String -> Int -> Int -> Int -> IO (Vector DMatrix)
casadi__DMatrix__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__DMatrix__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
dmatrix_sym__2 :: String -> Int -> Int -> Int -> IO (Vector DMatrix)
dmatrix_sym__2 = casadi__DMatrix__sym__2


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


-- classy wrapper
dmatrix_sym__3 :: String -> Sparsity -> Int -> IO (Vector DMatrix)
dmatrix_sym__3 = casadi__DMatrix__sym__3


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


-- classy wrapper
dmatrix_sym__4 :: String -> Sparsity -> IO DMatrix
dmatrix_sym__4 = casadi__DMatrix__sym__4


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


-- classy wrapper
dmatrix_sym__5 :: String -> IO DMatrix
dmatrix_sym__5 = casadi__DMatrix__sym__5


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


-- classy wrapper
dmatrix_sym__6 :: String -> Int -> IO DMatrix
dmatrix_sym__6 = casadi__DMatrix__sym__6


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


-- classy wrapper
dmatrix_sym__7 :: String -> Int -> Int -> IO DMatrix
dmatrix_sym__7 = casadi__DMatrix__sym__7


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


-- classy wrapper
dmatrix_tan :: DMatrixClass a => a -> IO DMatrix
dmatrix_tan x = casadi__DMatrix__tan (castDMatrix x)


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


-- classy wrapper
dmatrix_tanh :: DMatrixClass a => a -> IO DMatrix
dmatrix_tanh x = casadi__DMatrix__tanh (castDMatrix x)


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


-- classy wrapper
dmatrix_toScalar :: DMatrixClass a => a -> IO Double
dmatrix_toScalar x = casadi__DMatrix__toScalar (castDMatrix x)


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


-- classy wrapper
dmatrix_trans :: DMatrixClass a => a -> IO DMatrix
dmatrix_trans x = casadi__DMatrix__trans (castDMatrix x)


-- direct wrapper
foreign import ccall unsafe "casadi__DMatrix__triplet__0" c_casadi__DMatrix__triplet__0
  :: Ptr (Ptr StdString) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr (StdVec CDouble) -> CInt -> CInt -> IO (Ptr DMatrix')
casadi__DMatrix__triplet__0
  :: Vector Int -> Vector Int -> Vector Double -> Int -> Int -> IO DMatrix
casadi__DMatrix__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__DMatrix__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
dmatrix_triplet__0 :: Vector Int -> Vector Int -> Vector Double -> Int -> Int -> IO DMatrix
dmatrix_triplet__0 = casadi__DMatrix__triplet__0


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


-- classy wrapper
dmatrix_triplet__1 :: Vector Int -> Vector Int -> Vector Double -> IO DMatrix
dmatrix_triplet__1 = casadi__DMatrix__triplet__1


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


-- classy wrapper
dmatrix_unary :: Int -> DMatrix -> IO DMatrix
dmatrix_unary = casadi__DMatrix__unary


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


-- classy wrapper
dmatrix_zeros__0 :: Sparsity -> IO DMatrix
dmatrix_zeros__0 = casadi__DMatrix__zeros__0


-- direct wrapper
foreign import ccall unsafe "casadi__DMatrix__zeros__1" c_casadi__DMatrix__zeros__1
  :: Ptr (Ptr StdString) -> IO (Ptr DMatrix')
casadi__DMatrix__zeros__1
  :: IO DMatrix
casadi__DMatrix__zeros__1  =

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


-- classy wrapper
dmatrix_zeros__1 :: IO DMatrix
dmatrix_zeros__1 = casadi__DMatrix__zeros__1


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


-- classy wrapper
dmatrix_zeros__2 :: Int -> IO DMatrix
dmatrix_zeros__2 = casadi__DMatrix__zeros__2


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


-- classy wrapper
dmatrix_zeros__3 :: Int -> Int -> IO DMatrix
dmatrix_zeros__3 = casadi__DMatrix__zeros__3