{-# OPTIONS_GHC -Wall #-} {-# OPTIONS_GHC -fno-warn-unused-imports #-} {-# OPTIONS_GHC -fno-warn-orphans #-} {-# Language ForeignFunctionInterface #-} {-# Language FlexibleInstances #-} {-# Language MultiParamTypeClasses #-} module Casadi.Core.Classes.IMatrix ( IMatrix, IMatrixClass(..), imatrix__0, imatrix__1, imatrix__2, imatrix__3, imatrix__4, imatrix__5, imatrix__6, imatrix__7, imatrix__8, imatrix___add__, imatrix___constpow__, imatrix___copysign__, imatrix___div__, imatrix___eq__, imatrix___ge__, imatrix___gt__, imatrix___le__, imatrix___lt__, imatrix___mldivide__, imatrix___mpower__, imatrix___mrdivide__, imatrix___mul__, imatrix___ne__, imatrix___nonzero__, imatrix___pow__, imatrix___radd__, imatrix___rdiv__, imatrix___req__, imatrix___rge__, imatrix___rgt__, imatrix___rle__, imatrix___rlt__, imatrix___rmul__, imatrix___rne__, imatrix___rsub__, imatrix___rtruediv__, imatrix___sub__, imatrix___truediv____0, imatrix___truediv____1, imatrix_append, imatrix_appendColumns, imatrix_arccos, imatrix_arccosh, imatrix_arcsin, imatrix_arcsinh, imatrix_arctan, imatrix_arctan2, imatrix_arctanh, imatrix_at, imatrix_binary, imatrix_ceil, imatrix_className, imatrix_clear, imatrix_colind__0, imatrix_colind__1, imatrix_cos, imatrix_cosh, imatrix_data__0, imatrix_data__1, imatrix_densify__0, imatrix_densify__1, imatrix_dimString, imatrix_elem__0, imatrix_elem__1, imatrix_enlarge, imatrix_erase, imatrix_erf, imatrix_erfinv, imatrix_exp, imatrix_eye, imatrix_fabs, imatrix_floor, imatrix_fmax, imatrix_fmin, imatrix_getElement__0, imatrix_getElement__1, imatrix_getEqualityCheckingDepth, imatrix_getMaxNumCallsInPrint, imatrix_getNZ__0, imatrix_getNZ__1, imatrix_getNZ__2, imatrix_getNZ__3, imatrix_getName, imatrix_getValue, imatrix_get__0, imatrix_get__1, imatrix_get__2, imatrix_get__3, imatrix_get__4, imatrix_get__5, imatrix_hasNZ, imatrix_hasNonStructuralZeros, imatrix_if_else_zero, imatrix_indexed__0, imatrix_indexed__1, imatrix_indexed__2, imatrix_indexed__3, imatrix_indexed__4, imatrix_indexed__5, imatrix_indexed_assignment__0, imatrix_indexed_assignment__1, imatrix_indexed_assignment__2, imatrix_indexed_assignment__3, imatrix_indexed_assignment__4, imatrix_indexed_assignment__5, imatrix_indexed_one_based__0, imatrix_indexed_one_based__1, imatrix_indexed_one_based__2, imatrix_indexed_one_based_assignment__0, imatrix_indexed_one_based_assignment__1, imatrix_indexed_one_based_assignment__2, imatrix_indexed_zero_based__0, imatrix_indexed_zero_based__1, imatrix_indexed_zero_based__2, imatrix_indexed_zero_based_assignment__0, imatrix_indexed_zero_based_assignment__1, imatrix_indexed_zero_based_assignment__2, imatrix_inf__0, imatrix_inf__1, imatrix_inf__2, imatrix_inf__3, imatrix_isConstant, imatrix_isDense, imatrix_isEmpty__0, imatrix_isEmpty__1, imatrix_isEqual, imatrix_isIdentity, imatrix_isInteger, imatrix_isMinusOne, imatrix_isOne, imatrix_isRegular, imatrix_isScalar__0, imatrix_isScalar__1, imatrix_isSmooth, imatrix_isSquare, imatrix_isSymbolic, imatrix_isSymbolicSparse, imatrix_isTril, imatrix_isTriu, imatrix_isVector, imatrix_isZero, imatrix_log, imatrix_log10, imatrix_logic_and, imatrix_logic_not, imatrix_logic_or, imatrix_matrix_matrix, imatrix_matrix_scalar, imatrix_mul__0, imatrix_mul__1, imatrix_mul_full__0, imatrix_mul_full__1, imatrix_mul_no_alloc_nn__0, imatrix_mul_no_alloc_nn__1, imatrix_mul_no_alloc_nt, imatrix_mul_no_alloc_tn__0, imatrix_mul_no_alloc_tn__1, imatrix_mul_smart, imatrix_nan__0, imatrix_nan__1, imatrix_nan__2, imatrix_nan__3, imatrix_numel, imatrix_nz_indexed, imatrix_nz_indexed_assignment, imatrix_nz_indexed_one_based__0, imatrix_nz_indexed_one_based__1, imatrix_nz_indexed_one_based_assignment__0, imatrix_nz_indexed_one_based_assignment__1, imatrix_nz_indexed_zero_based__0, imatrix_nz_indexed_zero_based__1, imatrix_nz_indexed_zero_based_assignment__0, imatrix_nz_indexed_zero_based_assignment__1, imatrix_ones__0, imatrix_ones__1, imatrix_ones__2, imatrix_ones__3, imatrix_printDense, imatrix_printScalar, imatrix_printSparse, imatrix_printVector, imatrix_printme, imatrix_quad_form, imatrix_remove, imatrix_repmat__0, imatrix_repmat__1, imatrix_repmat__2, imatrix_repmat__3, imatrix_reserve__0, imatrix_reserve__1, imatrix_resize, imatrix_row__0, imatrix_row__1, imatrix_sanityCheck__0, imatrix_sanityCheck__1, imatrix_scalar_matrix, imatrix_setAll, imatrix_setEqualityCheckingDepth__0, imatrix_setEqualityCheckingDepth__1, imatrix_setMaxNumCallsInPrint__0, imatrix_setMaxNumCallsInPrint__1, imatrix_setNZ__0, imatrix_setNZ__1, imatrix_setNZ__2, imatrix_setNZ__3, imatrix_setPrecision, imatrix_setScientific, imatrix_setSparse__0, imatrix_setSparse__1, imatrix_setSub__0, imatrix_setSub__1, imatrix_setSub__10, imatrix_setSub__11, imatrix_setSub__12, imatrix_setSub__13, imatrix_setSub__14, imatrix_setSub__15, imatrix_setSub__16, imatrix_setSub__2, imatrix_setSub__3, imatrix_setSub__4, imatrix_setSub__5, imatrix_setSub__6, imatrix_setSub__7, imatrix_setSub__8, imatrix_setSub__9, imatrix_setWidth, imatrix_setZero, imatrix_set__0, imatrix_set__1, imatrix_set__2, imatrix_set__3, imatrix_set__4, imatrix_set__5, imatrix_sign, imatrix_sin, imatrix_sinh, imatrix_size1, imatrix_size2, imatrix_sizeD, imatrix_sizeL, imatrix_sizeU, imatrix_size__0, imatrix_size__1, imatrix_sparse__0, imatrix_sparse__1, imatrix_sparse__2, imatrix_sparsify__0, imatrix_sparsify__1, imatrix_sparsityRef__0, imatrix_sparsityRef__1, imatrix_sparsity__0, imatrix_sparsity__1, imatrix_sqrt, imatrix_sub__0, imatrix_sub__1, imatrix_sub__10, imatrix_sub__11, imatrix_sub__12, imatrix_sub__13, imatrix_sub__14, imatrix_sub__15, imatrix_sub__16, imatrix_sub__17, imatrix_sub__2, imatrix_sub__3, imatrix_sub__4, imatrix_sub__5, imatrix_sub__6, imatrix_sub__7, imatrix_sub__8, imatrix_sub__9, imatrix_sym__0, imatrix_sym__1, imatrix_sym__2, imatrix_sym__3, imatrix_sym__4, imatrix_sym__5, imatrix_sym__6, imatrix_sym__7, imatrix_tan, imatrix_tanh, imatrix_toScalar, imatrix_trans, imatrix_triplet__0, imatrix_triplet__1, imatrix_unary, imatrix_zeros__0, imatrix_zeros__1, imatrix_zeros__2, imatrix_zeros__3, ) where import Prelude hiding ( Functor ) import Data.Vector ( Vector ) import Foreign.C.Types import Foreign.Marshal ( new, free ) import Foreign.Storable ( peek ) import Foreign.Ptr ( Ptr, nullPtr ) import Foreign.ForeignPtr ( newForeignPtr ) import System.IO.Unsafe ( unsafePerformIO ) -- for show instances import Casadi.Core.Classes.PrintableObject import Casadi.Internal.CToolsInstances ( ) import Casadi.Internal.FormatException ( formatException ) import Casadi.Internal.MarshalTypes ( StdVec, StdString) -- StdPair StdOstream' import Casadi.Internal.Marshal ( Marshal(..), withMarshal ) import Casadi.Internal.WrapReturn ( WrapReturn(..) ) import Casadi.Core.Data import Casadi.Core.Enums instance Show IMatrix where show = unsafePerformIO . printableObject_getDescription -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__CONSTRUCTOR__0" c_casadi__IMatrix__CONSTRUCTOR__0 :: Ptr (Ptr StdString) -> Ptr (StdVec CInt) -> CInt -> CInt -> IO (Ptr IMatrix') casadi__IMatrix__CONSTRUCTOR__0 :: Vector Int -> Int -> Int -> IO IMatrix casadi__IMatrix__CONSTRUCTOR__0 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__CONSTRUCTOR__0 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix__0 :: Vector Int -> Int -> Int -> IO IMatrix imatrix__0 = casadi__IMatrix__CONSTRUCTOR__0 -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__CONSTRUCTOR__1" c_casadi__IMatrix__CONSTRUCTOR__1 :: Ptr (Ptr StdString) -> Ptr (StdVec CInt) -> IO (Ptr IMatrix') casadi__IMatrix__CONSTRUCTOR__1 :: Vector Int -> IO IMatrix casadi__IMatrix__CONSTRUCTOR__1 x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__CONSTRUCTOR__1 errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix__1 :: Vector Int -> IO IMatrix imatrix__1 = casadi__IMatrix__CONSTRUCTOR__1 -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__CONSTRUCTOR__2" c_casadi__IMatrix__CONSTRUCTOR__2 :: Ptr (Ptr StdString) -> CDouble -> IO (Ptr IMatrix') casadi__IMatrix__CONSTRUCTOR__2 :: Double -> IO IMatrix casadi__IMatrix__CONSTRUCTOR__2 x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__CONSTRUCTOR__2 errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix__2 :: Double -> IO IMatrix imatrix__2 = casadi__IMatrix__CONSTRUCTOR__2 -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__CONSTRUCTOR__3" c_casadi__IMatrix__CONSTRUCTOR__3 :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> IO (Ptr IMatrix') casadi__IMatrix__CONSTRUCTOR__3 :: Sparsity -> Vector Int -> IO IMatrix casadi__IMatrix__CONSTRUCTOR__3 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__CONSTRUCTOR__3 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix__3 :: Sparsity -> Vector Int -> IO IMatrix imatrix__3 = casadi__IMatrix__CONSTRUCTOR__3 -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__CONSTRUCTOR__4" c_casadi__IMatrix__CONSTRUCTOR__4 :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr IMatrix') casadi__IMatrix__CONSTRUCTOR__4 :: Sparsity -> IO IMatrix casadi__IMatrix__CONSTRUCTOR__4 x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__CONSTRUCTOR__4 errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix__4 :: Sparsity -> IO IMatrix imatrix__4 = casadi__IMatrix__CONSTRUCTOR__4 -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__CONSTRUCTOR__5" c_casadi__IMatrix__CONSTRUCTOR__5 :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> IO (Ptr IMatrix') casadi__IMatrix__CONSTRUCTOR__5 :: Sparsity -> Int -> IO IMatrix casadi__IMatrix__CONSTRUCTOR__5 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__CONSTRUCTOR__5 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix__5 :: Sparsity -> Int -> IO IMatrix imatrix__5 = casadi__IMatrix__CONSTRUCTOR__5 -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__CONSTRUCTOR__6" c_casadi__IMatrix__CONSTRUCTOR__6 :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr (StdVec CInt))) -> IO (Ptr IMatrix') casadi__IMatrix__CONSTRUCTOR__6 :: Vector (Vector Int) -> IO IMatrix casadi__IMatrix__CONSTRUCTOR__6 x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__CONSTRUCTOR__6 errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix__6 :: Vector (Vector Int) -> IO IMatrix imatrix__6 = casadi__IMatrix__CONSTRUCTOR__6 -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__CONSTRUCTOR__7" c_casadi__IMatrix__CONSTRUCTOR__7 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__CONSTRUCTOR__7 :: IMatrix -> IO IMatrix casadi__IMatrix__CONSTRUCTOR__7 x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__CONSTRUCTOR__7 errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix__7 :: IMatrix -> IO IMatrix imatrix__7 = casadi__IMatrix__CONSTRUCTOR__7 -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__CONSTRUCTOR__8" c_casadi__IMatrix__CONSTRUCTOR__8 :: Ptr (Ptr StdString) -> IO (Ptr IMatrix') casadi__IMatrix__CONSTRUCTOR__8 :: IO IMatrix casadi__IMatrix__CONSTRUCTOR__8 = do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__CONSTRUCTOR__8 errStrPtrP errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix__8 :: IO IMatrix imatrix__8 = casadi__IMatrix__CONSTRUCTOR__8 -- direct wrapper foreign import ccall unsafe "casadi__IMatrix____add__" c_casadi__IMatrix____add__ :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix____add__ :: IMatrix -> IMatrix -> IO IMatrix casadi__IMatrix____add__ x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix____add__ errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix___add__ :: IMatrixClass a => a -> IMatrix -> IO IMatrix imatrix___add__ x = casadi__IMatrix____add__ (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix____constpow__" c_casadi__IMatrix____constpow__ :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix____constpow__ :: IMatrix -> IMatrix -> IO IMatrix casadi__IMatrix____constpow__ x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix____constpow__ errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix___constpow__ :: IMatrixClass a => a -> IMatrix -> IO IMatrix imatrix___constpow__ x = casadi__IMatrix____constpow__ (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix____copysign__" c_casadi__IMatrix____copysign__ :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix____copysign__ :: IMatrix -> IMatrix -> IO IMatrix casadi__IMatrix____copysign__ x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix____copysign__ errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix___copysign__ :: IMatrixClass a => a -> IMatrix -> IO IMatrix imatrix___copysign__ x = casadi__IMatrix____copysign__ (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix____div__" c_casadi__IMatrix____div__ :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix____div__ :: IMatrix -> IMatrix -> IO IMatrix casadi__IMatrix____div__ x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix____div__ errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix___div__ :: IMatrixClass a => a -> IMatrix -> IO IMatrix imatrix___div__ x = casadi__IMatrix____div__ (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix____eq__" c_casadi__IMatrix____eq__ :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix____eq__ :: IMatrix -> IMatrix -> IO IMatrix casadi__IMatrix____eq__ x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix____eq__ errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix___eq__ :: IMatrixClass a => a -> IMatrix -> IO IMatrix imatrix___eq__ x = casadi__IMatrix____eq__ (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix____ge__" c_casadi__IMatrix____ge__ :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix____ge__ :: IMatrix -> IMatrix -> IO IMatrix casadi__IMatrix____ge__ x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix____ge__ errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix___ge__ :: IMatrixClass a => a -> IMatrix -> IO IMatrix imatrix___ge__ x = casadi__IMatrix____ge__ (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix____gt__" c_casadi__IMatrix____gt__ :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix____gt__ :: IMatrix -> IMatrix -> IO IMatrix casadi__IMatrix____gt__ x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix____gt__ errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix___gt__ :: IMatrixClass a => a -> IMatrix -> IO IMatrix imatrix___gt__ x = casadi__IMatrix____gt__ (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix____le__" c_casadi__IMatrix____le__ :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix____le__ :: IMatrix -> IMatrix -> IO IMatrix casadi__IMatrix____le__ x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix____le__ errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix___le__ :: IMatrixClass a => a -> IMatrix -> IO IMatrix imatrix___le__ x = casadi__IMatrix____le__ (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix____lt__" c_casadi__IMatrix____lt__ :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix____lt__ :: IMatrix -> IMatrix -> IO IMatrix casadi__IMatrix____lt__ x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix____lt__ errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix___lt__ :: IMatrixClass a => a -> IMatrix -> IO IMatrix imatrix___lt__ x = casadi__IMatrix____lt__ (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix____mldivide__" c_casadi__IMatrix____mldivide__ :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix____mldivide__ :: IMatrix -> IMatrix -> IO IMatrix casadi__IMatrix____mldivide__ x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix____mldivide__ errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix___mldivide__ :: IMatrixClass a => a -> IMatrix -> IO IMatrix imatrix___mldivide__ x = casadi__IMatrix____mldivide__ (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix____mpower__" c_casadi__IMatrix____mpower__ :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix____mpower__ :: IMatrix -> IMatrix -> IO IMatrix casadi__IMatrix____mpower__ x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix____mpower__ errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix___mpower__ :: IMatrixClass a => a -> IMatrix -> IO IMatrix imatrix___mpower__ x = casadi__IMatrix____mpower__ (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix____mrdivide__" c_casadi__IMatrix____mrdivide__ :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix____mrdivide__ :: IMatrix -> IMatrix -> IO IMatrix casadi__IMatrix____mrdivide__ x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix____mrdivide__ errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix___mrdivide__ :: IMatrixClass a => a -> IMatrix -> IO IMatrix imatrix___mrdivide__ x = casadi__IMatrix____mrdivide__ (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix____mul__" c_casadi__IMatrix____mul__ :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix____mul__ :: IMatrix -> IMatrix -> IO IMatrix casadi__IMatrix____mul__ x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix____mul__ errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix___mul__ :: IMatrixClass a => a -> IMatrix -> IO IMatrix imatrix___mul__ x = casadi__IMatrix____mul__ (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix____ne__" c_casadi__IMatrix____ne__ :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix____ne__ :: IMatrix -> IMatrix -> IO IMatrix casadi__IMatrix____ne__ x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix____ne__ errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix___ne__ :: IMatrixClass a => a -> IMatrix -> IO IMatrix imatrix___ne__ x = casadi__IMatrix____ne__ (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix____nonzero__" c_casadi__IMatrix____nonzero__ :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt casadi__IMatrix____nonzero__ :: IMatrix -> IO Bool casadi__IMatrix____nonzero__ x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix____nonzero__ errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix___nonzero__ :: IMatrixClass a => a -> IO Bool imatrix___nonzero__ x = casadi__IMatrix____nonzero__ (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix____pow__" c_casadi__IMatrix____pow__ :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix____pow__ :: IMatrix -> IMatrix -> IO IMatrix casadi__IMatrix____pow__ x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix____pow__ errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix___pow__ :: IMatrixClass a => a -> IMatrix -> IO IMatrix imatrix___pow__ x = casadi__IMatrix____pow__ (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix____radd__" c_casadi__IMatrix____radd__ :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix____radd__ :: IMatrix -> IMatrix -> IO IMatrix casadi__IMatrix____radd__ x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix____radd__ errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix___radd__ :: IMatrixClass a => a -> IMatrix -> IO IMatrix imatrix___radd__ x = casadi__IMatrix____radd__ (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix____rdiv__" c_casadi__IMatrix____rdiv__ :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix____rdiv__ :: IMatrix -> IMatrix -> IO IMatrix casadi__IMatrix____rdiv__ x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix____rdiv__ errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix___rdiv__ :: IMatrixClass a => a -> IMatrix -> IO IMatrix imatrix___rdiv__ x = casadi__IMatrix____rdiv__ (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix____req__" c_casadi__IMatrix____req__ :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix____req__ :: IMatrix -> IMatrix -> IO IMatrix casadi__IMatrix____req__ x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix____req__ errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix___req__ :: IMatrixClass a => a -> IMatrix -> IO IMatrix imatrix___req__ x = casadi__IMatrix____req__ (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix____rge__" c_casadi__IMatrix____rge__ :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix____rge__ :: IMatrix -> IMatrix -> IO IMatrix casadi__IMatrix____rge__ x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix____rge__ errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix___rge__ :: IMatrixClass a => a -> IMatrix -> IO IMatrix imatrix___rge__ x = casadi__IMatrix____rge__ (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix____rgt__" c_casadi__IMatrix____rgt__ :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix____rgt__ :: IMatrix -> IMatrix -> IO IMatrix casadi__IMatrix____rgt__ x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix____rgt__ errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix___rgt__ :: IMatrixClass a => a -> IMatrix -> IO IMatrix imatrix___rgt__ x = casadi__IMatrix____rgt__ (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix____rle__" c_casadi__IMatrix____rle__ :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix____rle__ :: IMatrix -> IMatrix -> IO IMatrix casadi__IMatrix____rle__ x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix____rle__ errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix___rle__ :: IMatrixClass a => a -> IMatrix -> IO IMatrix imatrix___rle__ x = casadi__IMatrix____rle__ (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix____rlt__" c_casadi__IMatrix____rlt__ :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix____rlt__ :: IMatrix -> IMatrix -> IO IMatrix casadi__IMatrix____rlt__ x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix____rlt__ errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix___rlt__ :: IMatrixClass a => a -> IMatrix -> IO IMatrix imatrix___rlt__ x = casadi__IMatrix____rlt__ (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix____rmul__" c_casadi__IMatrix____rmul__ :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix____rmul__ :: IMatrix -> IMatrix -> IO IMatrix casadi__IMatrix____rmul__ x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix____rmul__ errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix___rmul__ :: IMatrixClass a => a -> IMatrix -> IO IMatrix imatrix___rmul__ x = casadi__IMatrix____rmul__ (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix____rne__" c_casadi__IMatrix____rne__ :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix____rne__ :: IMatrix -> IMatrix -> IO IMatrix casadi__IMatrix____rne__ x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix____rne__ errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix___rne__ :: IMatrixClass a => a -> IMatrix -> IO IMatrix imatrix___rne__ x = casadi__IMatrix____rne__ (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix____rsub__" c_casadi__IMatrix____rsub__ :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix____rsub__ :: IMatrix -> IMatrix -> IO IMatrix casadi__IMatrix____rsub__ x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix____rsub__ errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix___rsub__ :: IMatrixClass a => a -> IMatrix -> IO IMatrix imatrix___rsub__ x = casadi__IMatrix____rsub__ (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix____rtruediv__" c_casadi__IMatrix____rtruediv__ :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix____rtruediv__ :: IMatrix -> IMatrix -> IO IMatrix casadi__IMatrix____rtruediv__ x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix____rtruediv__ errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix___rtruediv__ :: IMatrixClass a => a -> IMatrix -> IO IMatrix imatrix___rtruediv__ x = casadi__IMatrix____rtruediv__ (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix____sub__" c_casadi__IMatrix____sub__ :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix____sub__ :: IMatrix -> IMatrix -> IO IMatrix casadi__IMatrix____sub__ x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix____sub__ errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix___sub__ :: IMatrixClass a => a -> IMatrix -> IO IMatrix imatrix___sub__ x = casadi__IMatrix____sub__ (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix____truediv____0" c_casadi__IMatrix____truediv____0 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix____truediv____0 :: IMatrix -> IMatrix -> IO IMatrix casadi__IMatrix____truediv____0 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix____truediv____0 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix___truediv____0 :: IMatrixClass a => a -> IMatrix -> IO IMatrix imatrix___truediv____0 x = casadi__IMatrix____truediv____0 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix____truediv____1" c_casadi__IMatrix____truediv____1 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix____truediv____1 :: IMatrix -> IMatrix -> IO IMatrix casadi__IMatrix____truediv____1 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix____truediv____1 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix___truediv____1 :: IMatrixClass a => a -> IMatrix -> IO IMatrix imatrix___truediv____1 x = casadi__IMatrix____truediv____1 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__append" c_casadi__IMatrix__append :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO () casadi__IMatrix__append :: IMatrix -> IMatrix -> IO () casadi__IMatrix__append x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__append errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_append :: IMatrixClass a => a -> IMatrix -> IO () imatrix_append x = casadi__IMatrix__append (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__appendColumns" c_casadi__IMatrix__appendColumns :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO () casadi__IMatrix__appendColumns :: IMatrix -> IMatrix -> IO () casadi__IMatrix__appendColumns x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__appendColumns errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_appendColumns :: IMatrixClass a => a -> IMatrix -> IO () imatrix_appendColumns x = casadi__IMatrix__appendColumns (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__arccos" c_casadi__IMatrix__arccos :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__arccos :: IMatrix -> IO IMatrix casadi__IMatrix__arccos x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__arccos errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_arccos :: IMatrixClass a => a -> IO IMatrix imatrix_arccos x = casadi__IMatrix__arccos (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__arccosh" c_casadi__IMatrix__arccosh :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__arccosh :: IMatrix -> IO IMatrix casadi__IMatrix__arccosh x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__arccosh errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_arccosh :: IMatrixClass a => a -> IO IMatrix imatrix_arccosh x = casadi__IMatrix__arccosh (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__arcsin" c_casadi__IMatrix__arcsin :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__arcsin :: IMatrix -> IO IMatrix casadi__IMatrix__arcsin x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__arcsin errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_arcsin :: IMatrixClass a => a -> IO IMatrix imatrix_arcsin x = casadi__IMatrix__arcsin (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__arcsinh" c_casadi__IMatrix__arcsinh :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__arcsinh :: IMatrix -> IO IMatrix casadi__IMatrix__arcsinh x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__arcsinh errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_arcsinh :: IMatrixClass a => a -> IO IMatrix imatrix_arcsinh x = casadi__IMatrix__arcsinh (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__arctan" c_casadi__IMatrix__arctan :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__arctan :: IMatrix -> IO IMatrix casadi__IMatrix__arctan x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__arctan errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_arctan :: IMatrixClass a => a -> IO IMatrix imatrix_arctan x = casadi__IMatrix__arctan (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__arctan2" c_casadi__IMatrix__arctan2 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__arctan2 :: IMatrix -> IMatrix -> IO IMatrix casadi__IMatrix__arctan2 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__arctan2 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_arctan2 :: IMatrixClass a => a -> IMatrix -> IO IMatrix imatrix_arctan2 x = casadi__IMatrix__arctan2 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__arctanh" c_casadi__IMatrix__arctanh :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__arctanh :: IMatrix -> IO IMatrix casadi__IMatrix__arctanh x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__arctanh errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_arctanh :: IMatrixClass a => a -> IO IMatrix imatrix_arctanh x = casadi__IMatrix__arctanh (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__at" c_casadi__IMatrix__at :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> IO CInt casadi__IMatrix__at :: IMatrix -> Int -> IO Int casadi__IMatrix__at x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__at errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_at :: IMatrixClass a => a -> Int -> IO Int imatrix_at x = casadi__IMatrix__at (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__binary" c_casadi__IMatrix__binary :: Ptr (Ptr StdString) -> CInt -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__binary :: Int -> IMatrix -> IMatrix -> IO IMatrix casadi__IMatrix__binary x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__binary errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_binary :: Int -> IMatrix -> IMatrix -> IO IMatrix imatrix_binary = casadi__IMatrix__binary -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__ceil" c_casadi__IMatrix__ceil :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__ceil :: IMatrix -> IO IMatrix casadi__IMatrix__ceil x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__ceil errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_ceil :: IMatrixClass a => a -> IO IMatrix imatrix_ceil x = casadi__IMatrix__ceil (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__className" c_casadi__IMatrix__className :: Ptr (Ptr StdString) -> IO (Ptr StdString) casadi__IMatrix__className :: IO String casadi__IMatrix__className = do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__className errStrPtrP errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_className :: IO String imatrix_className = casadi__IMatrix__className -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__clear" c_casadi__IMatrix__clear :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO () casadi__IMatrix__clear :: IMatrix -> IO () casadi__IMatrix__clear x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__clear errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_clear :: IMatrixClass a => a -> IO () imatrix_clear x = casadi__IMatrix__clear (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__colind__0" c_casadi__IMatrix__colind__0 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> IO CInt casadi__IMatrix__colind__0 :: IMatrix -> Int -> IO Int casadi__IMatrix__colind__0 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__colind__0 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_colind__0 :: IMatrixClass a => a -> Int -> IO Int imatrix_colind__0 x = casadi__IMatrix__colind__0 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__colind__1" c_casadi__IMatrix__colind__1 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr (StdVec CInt)) casadi__IMatrix__colind__1 :: IMatrix -> IO (Vector Int) casadi__IMatrix__colind__1 x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__colind__1 errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_colind__1 :: IMatrixClass a => a -> IO (Vector Int) imatrix_colind__1 x = casadi__IMatrix__colind__1 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__cos" c_casadi__IMatrix__cos :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__cos :: IMatrix -> IO IMatrix casadi__IMatrix__cos x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__cos errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_cos :: IMatrixClass a => a -> IO IMatrix imatrix_cos x = casadi__IMatrix__cos (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__cosh" c_casadi__IMatrix__cosh :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__cosh :: IMatrix -> IO IMatrix casadi__IMatrix__cosh x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__cosh errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_cosh :: IMatrixClass a => a -> IO IMatrix imatrix_cosh x = casadi__IMatrix__cosh (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__data__0" c_casadi__IMatrix__data__0 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr (StdVec CInt)) casadi__IMatrix__data__0 :: IMatrix -> IO (Vector Int) casadi__IMatrix__data__0 x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__data__0 errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_data__0 :: IMatrixClass a => a -> IO (Vector Int) imatrix_data__0 x = casadi__IMatrix__data__0 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__data__1" c_casadi__IMatrix__data__1 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr (StdVec CInt)) casadi__IMatrix__data__1 :: IMatrix -> IO (Vector Int) casadi__IMatrix__data__1 x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__data__1 errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_data__1 :: IMatrixClass a => a -> IO (Vector Int) imatrix_data__1 x = casadi__IMatrix__data__1 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__densify__0" c_casadi__IMatrix__densify__0 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO () casadi__IMatrix__densify__0 :: IMatrix -> IO () casadi__IMatrix__densify__0 x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__densify__0 errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_densify__0 :: IMatrixClass a => a -> IO () imatrix_densify__0 x = casadi__IMatrix__densify__0 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__densify__1" c_casadi__IMatrix__densify__1 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> IO () casadi__IMatrix__densify__1 :: IMatrix -> Int -> IO () casadi__IMatrix__densify__1 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__densify__1 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_densify__1 :: IMatrixClass a => a -> Int -> IO () imatrix_densify__1 x = casadi__IMatrix__densify__1 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__dimString" c_casadi__IMatrix__dimString :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr StdString) casadi__IMatrix__dimString :: IMatrix -> IO String casadi__IMatrix__dimString x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__dimString errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_dimString :: IMatrixClass a => a -> IO String imatrix_dimString x = casadi__IMatrix__dimString (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__elem__0" c_casadi__IMatrix__elem__0 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> IO CInt casadi__IMatrix__elem__0 :: IMatrix -> Int -> IO Int casadi__IMatrix__elem__0 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__elem__0 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_elem__0 :: IMatrixClass a => a -> Int -> IO Int imatrix_elem__0 x = casadi__IMatrix__elem__0 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__elem__1" c_casadi__IMatrix__elem__1 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> CInt -> IO CInt casadi__IMatrix__elem__1 :: IMatrix -> Int -> Int -> IO Int casadi__IMatrix__elem__1 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__elem__1 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_elem__1 :: IMatrixClass a => a -> Int -> Int -> IO Int imatrix_elem__1 x = casadi__IMatrix__elem__1 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__enlarge" c_casadi__IMatrix__enlarge :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> CInt -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO () casadi__IMatrix__enlarge :: IMatrix -> Int -> Int -> Vector Int -> Vector Int -> IO () casadi__IMatrix__enlarge x0 x1 x2 x3 x4 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> withMarshal x4 $ \x4' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__enlarge errStrPtrP x0' x1' x2' x3' x4' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_enlarge :: IMatrixClass a => a -> Int -> Int -> Vector Int -> Vector Int -> IO () imatrix_enlarge x = casadi__IMatrix__enlarge (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__erase" c_casadi__IMatrix__erase :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO () casadi__IMatrix__erase :: IMatrix -> Vector Int -> Vector Int -> IO () casadi__IMatrix__erase x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__erase errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_erase :: IMatrixClass a => a -> Vector Int -> Vector Int -> IO () imatrix_erase x = casadi__IMatrix__erase (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__erf" c_casadi__IMatrix__erf :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__erf :: IMatrix -> IO IMatrix casadi__IMatrix__erf x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__erf errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_erf :: IMatrixClass a => a -> IO IMatrix imatrix_erf x = casadi__IMatrix__erf (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__erfinv" c_casadi__IMatrix__erfinv :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__erfinv :: IMatrix -> IO IMatrix casadi__IMatrix__erfinv x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__erfinv errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_erfinv :: IMatrixClass a => a -> IO IMatrix imatrix_erfinv x = casadi__IMatrix__erfinv (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__exp" c_casadi__IMatrix__exp :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__exp :: IMatrix -> IO IMatrix casadi__IMatrix__exp x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__exp errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_exp :: IMatrixClass a => a -> IO IMatrix imatrix_exp x = casadi__IMatrix__exp (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__eye" c_casadi__IMatrix__eye :: Ptr (Ptr StdString) -> CInt -> IO (Ptr IMatrix') casadi__IMatrix__eye :: Int -> IO IMatrix casadi__IMatrix__eye x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__eye errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_eye :: Int -> IO IMatrix imatrix_eye = casadi__IMatrix__eye -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__fabs" c_casadi__IMatrix__fabs :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__fabs :: IMatrix -> IO IMatrix casadi__IMatrix__fabs x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__fabs errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_fabs :: IMatrixClass a => a -> IO IMatrix imatrix_fabs x = casadi__IMatrix__fabs (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__floor" c_casadi__IMatrix__floor :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__floor :: IMatrix -> IO IMatrix casadi__IMatrix__floor x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__floor errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_floor :: IMatrixClass a => a -> IO IMatrix imatrix_floor x = casadi__IMatrix__floor (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__fmax" c_casadi__IMatrix__fmax :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__fmax :: IMatrix -> IMatrix -> IO IMatrix casadi__IMatrix__fmax x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__fmax errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_fmax :: IMatrixClass a => a -> IMatrix -> IO IMatrix imatrix_fmax x = casadi__IMatrix__fmax (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__fmin" c_casadi__IMatrix__fmin :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__fmin :: IMatrix -> IMatrix -> IO IMatrix casadi__IMatrix__fmin x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__fmin errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_fmin :: IMatrixClass a => a -> IMatrix -> IO IMatrix imatrix_fmin x = casadi__IMatrix__fmin (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__get__0" c_casadi__IMatrix__get__0 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO () casadi__IMatrix__get__0 :: IMatrix -> IMatrix -> IO () casadi__IMatrix__get__0 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__get__0 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_get__0 :: IMatrixClass a => a -> IMatrix -> IO () imatrix_get__0 x = casadi__IMatrix__get__0 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__get__1" c_casadi__IMatrix__get__1 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> IO () casadi__IMatrix__get__1 :: IMatrix -> IMatrix -> SparsityType -> IO () casadi__IMatrix__get__1 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__get__1 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_get__1 :: IMatrixClass a => a -> IMatrix -> SparsityType -> IO () imatrix_get__1 x = casadi__IMatrix__get__1 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__get__2" c_casadi__IMatrix__get__2 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec CInt) -> IO () casadi__IMatrix__get__2 :: IMatrix -> Vector Int -> IO () casadi__IMatrix__get__2 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__get__2 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_get__2 :: IMatrixClass a => a -> Vector Int -> IO () imatrix_get__2 x = casadi__IMatrix__get__2 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__get__3" c_casadi__IMatrix__get__3 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec CInt) -> CInt -> IO () casadi__IMatrix__get__3 :: IMatrix -> Vector Int -> SparsityType -> IO () casadi__IMatrix__get__3 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__get__3 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_get__3 :: IMatrixClass a => a -> Vector Int -> SparsityType -> IO () imatrix_get__3 x = casadi__IMatrix__get__3 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__get__4" c_casadi__IMatrix__get__4 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> IO () casadi__IMatrix__get__4 :: IMatrix -> Int -> IO () casadi__IMatrix__get__4 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__get__4 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_get__4 :: IMatrixClass a => a -> Int -> IO () imatrix_get__4 x = casadi__IMatrix__get__4 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__get__5" c_casadi__IMatrix__get__5 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> CInt -> IO () casadi__IMatrix__get__5 :: IMatrix -> Int -> SparsityType -> IO () casadi__IMatrix__get__5 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__get__5 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_get__5 :: IMatrixClass a => a -> Int -> SparsityType -> IO () imatrix_get__5 x = casadi__IMatrix__get__5 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__getElement__0" c_casadi__IMatrix__getElement__0 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> IO CInt casadi__IMatrix__getElement__0 :: IMatrix -> Int -> IO Int casadi__IMatrix__getElement__0 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__getElement__0 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_getElement__0 :: IMatrixClass a => a -> Int -> IO Int imatrix_getElement__0 x = casadi__IMatrix__getElement__0 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__getElement__1" c_casadi__IMatrix__getElement__1 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> CInt -> IO CInt casadi__IMatrix__getElement__1 :: IMatrix -> Int -> Int -> IO Int casadi__IMatrix__getElement__1 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__getElement__1 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_getElement__1 :: IMatrixClass a => a -> Int -> Int -> IO Int imatrix_getElement__1 x = casadi__IMatrix__getElement__1 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__getEqualityCheckingDepth" c_casadi__IMatrix__getEqualityCheckingDepth :: Ptr (Ptr StdString) -> IO CInt casadi__IMatrix__getEqualityCheckingDepth :: IO Int casadi__IMatrix__getEqualityCheckingDepth = do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__getEqualityCheckingDepth errStrPtrP errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_getEqualityCheckingDepth :: IO Int imatrix_getEqualityCheckingDepth = casadi__IMatrix__getEqualityCheckingDepth -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__getMaxNumCallsInPrint" c_casadi__IMatrix__getMaxNumCallsInPrint :: Ptr (Ptr StdString) -> IO CLong casadi__IMatrix__getMaxNumCallsInPrint :: IO Int casadi__IMatrix__getMaxNumCallsInPrint = do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__getMaxNumCallsInPrint errStrPtrP errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_getMaxNumCallsInPrint :: IO Int imatrix_getMaxNumCallsInPrint = casadi__IMatrix__getMaxNumCallsInPrint -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__getNZ__0" c_casadi__IMatrix__getNZ__0 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__getNZ__0 :: IMatrix -> IMatrix -> IO IMatrix casadi__IMatrix__getNZ__0 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__getNZ__0 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_getNZ__0 :: IMatrixClass a => a -> IMatrix -> IO IMatrix imatrix_getNZ__0 x = casadi__IMatrix__getNZ__0 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__getNZ__1" c_casadi__IMatrix__getNZ__1 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr Slice' -> IO (Ptr IMatrix') casadi__IMatrix__getNZ__1 :: IMatrix -> Slice -> IO IMatrix casadi__IMatrix__getNZ__1 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__getNZ__1 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_getNZ__1 :: IMatrixClass a => a -> Slice -> IO IMatrix imatrix_getNZ__1 x = casadi__IMatrix__getNZ__1 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__getNZ__2" c_casadi__IMatrix__getNZ__2 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec CInt) -> IO (Ptr IMatrix') casadi__IMatrix__getNZ__2 :: IMatrix -> Vector Int -> IO IMatrix casadi__IMatrix__getNZ__2 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__getNZ__2 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_getNZ__2 :: IMatrixClass a => a -> Vector Int -> IO IMatrix imatrix_getNZ__2 x = casadi__IMatrix__getNZ__2 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__getNZ__3" c_casadi__IMatrix__getNZ__3 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> IO (Ptr IMatrix') casadi__IMatrix__getNZ__3 :: IMatrix -> Int -> IO IMatrix casadi__IMatrix__getNZ__3 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__getNZ__3 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_getNZ__3 :: IMatrixClass a => a -> Int -> IO IMatrix imatrix_getNZ__3 x = casadi__IMatrix__getNZ__3 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__getName" c_casadi__IMatrix__getName :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr StdString) casadi__IMatrix__getName :: IMatrix -> IO String casadi__IMatrix__getName x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__getName errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_getName :: IMatrixClass a => a -> IO String imatrix_getName x = casadi__IMatrix__getName (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__getValue" c_casadi__IMatrix__getValue :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CDouble casadi__IMatrix__getValue :: IMatrix -> IO Double casadi__IMatrix__getValue x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__getValue errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_getValue :: IMatrixClass a => a -> IO Double imatrix_getValue x = casadi__IMatrix__getValue (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__hasNZ" c_casadi__IMatrix__hasNZ :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> CInt -> IO CInt casadi__IMatrix__hasNZ :: IMatrix -> Int -> Int -> IO Bool casadi__IMatrix__hasNZ x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__hasNZ errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_hasNZ :: IMatrixClass a => a -> Int -> Int -> IO Bool imatrix_hasNZ x = casadi__IMatrix__hasNZ (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__hasNonStructuralZeros" c_casadi__IMatrix__hasNonStructuralZeros :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt casadi__IMatrix__hasNonStructuralZeros :: IMatrix -> IO Bool casadi__IMatrix__hasNonStructuralZeros x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__hasNonStructuralZeros errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_hasNonStructuralZeros :: IMatrixClass a => a -> IO Bool imatrix_hasNonStructuralZeros x = casadi__IMatrix__hasNonStructuralZeros (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__if_else_zero" c_casadi__IMatrix__if_else_zero :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__if_else_zero :: IMatrix -> IMatrix -> IO IMatrix casadi__IMatrix__if_else_zero x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__if_else_zero errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_if_else_zero :: IMatrixClass a => a -> IMatrix -> IO IMatrix imatrix_if_else_zero x = casadi__IMatrix__if_else_zero (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__indexed__0" c_casadi__IMatrix__indexed__0 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr Slice' -> IO (Ptr IMatrix') casadi__IMatrix__indexed__0 :: IMatrix -> Slice -> IO IMatrix casadi__IMatrix__indexed__0 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__indexed__0 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_indexed__0 :: IMatrixClass a => a -> Slice -> IO IMatrix imatrix_indexed__0 x = casadi__IMatrix__indexed__0 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__indexed__1" c_casadi__IMatrix__indexed__1 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr Sparsity' -> IO (Ptr IMatrix') casadi__IMatrix__indexed__1 :: IMatrix -> Sparsity -> IO IMatrix casadi__IMatrix__indexed__1 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__indexed__1 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_indexed__1 :: IMatrixClass a => a -> Sparsity -> IO IMatrix imatrix_indexed__1 x = casadi__IMatrix__indexed__1 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__indexed__2" c_casadi__IMatrix__indexed__2 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__indexed__2 :: IMatrix -> IMatrix -> IMatrix -> IO IMatrix casadi__IMatrix__indexed__2 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__indexed__2 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_indexed__2 :: IMatrixClass a => a -> IMatrix -> IMatrix -> IO IMatrix imatrix_indexed__2 x = casadi__IMatrix__indexed__2 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__indexed__3" c_casadi__IMatrix__indexed__3 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr Slice' -> IO (Ptr IMatrix') casadi__IMatrix__indexed__3 :: IMatrix -> IMatrix -> Slice -> IO IMatrix casadi__IMatrix__indexed__3 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__indexed__3 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_indexed__3 :: IMatrixClass a => a -> IMatrix -> Slice -> IO IMatrix imatrix_indexed__3 x = casadi__IMatrix__indexed__3 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__indexed__4" c_casadi__IMatrix__indexed__4 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr Slice' -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__indexed__4 :: IMatrix -> Slice -> IMatrix -> IO IMatrix casadi__IMatrix__indexed__4 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__indexed__4 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_indexed__4 :: IMatrixClass a => a -> Slice -> IMatrix -> IO IMatrix imatrix_indexed__4 x = casadi__IMatrix__indexed__4 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__indexed__5" c_casadi__IMatrix__indexed__5 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr Slice' -> Ptr Slice' -> IO (Ptr IMatrix') casadi__IMatrix__indexed__5 :: IMatrix -> Slice -> Slice -> IO IMatrix casadi__IMatrix__indexed__5 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__indexed__5 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_indexed__5 :: IMatrixClass a => a -> Slice -> Slice -> IO IMatrix imatrix_indexed__5 x = casadi__IMatrix__indexed__5 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__indexed_assignment__0" c_casadi__IMatrix__indexed_assignment__0 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr Slice' -> Ptr IMatrix' -> IO () casadi__IMatrix__indexed_assignment__0 :: IMatrix -> Slice -> IMatrix -> IO () casadi__IMatrix__indexed_assignment__0 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__indexed_assignment__0 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_indexed_assignment__0 :: IMatrixClass a => a -> Slice -> IMatrix -> IO () imatrix_indexed_assignment__0 x = casadi__IMatrix__indexed_assignment__0 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__indexed_assignment__1" c_casadi__IMatrix__indexed_assignment__1 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr Sparsity' -> Ptr IMatrix' -> IO () casadi__IMatrix__indexed_assignment__1 :: IMatrix -> Sparsity -> IMatrix -> IO () casadi__IMatrix__indexed_assignment__1 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__indexed_assignment__1 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_indexed_assignment__1 :: IMatrixClass a => a -> Sparsity -> IMatrix -> IO () imatrix_indexed_assignment__1 x = casadi__IMatrix__indexed_assignment__1 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__indexed_assignment__2" c_casadi__IMatrix__indexed_assignment__2 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> IO () casadi__IMatrix__indexed_assignment__2 :: IMatrix -> IMatrix -> IMatrix -> IMatrix -> IO () casadi__IMatrix__indexed_assignment__2 x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__indexed_assignment__2 errStrPtrP x0' x1' x2' x3' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_indexed_assignment__2 :: IMatrixClass a => a -> IMatrix -> IMatrix -> IMatrix -> IO () imatrix_indexed_assignment__2 x = casadi__IMatrix__indexed_assignment__2 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__indexed_assignment__3" c_casadi__IMatrix__indexed_assignment__3 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr Slice' -> Ptr IMatrix' -> IO () casadi__IMatrix__indexed_assignment__3 :: IMatrix -> IMatrix -> Slice -> IMatrix -> IO () casadi__IMatrix__indexed_assignment__3 x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__indexed_assignment__3 errStrPtrP x0' x1' x2' x3' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_indexed_assignment__3 :: IMatrixClass a => a -> IMatrix -> Slice -> IMatrix -> IO () imatrix_indexed_assignment__3 x = casadi__IMatrix__indexed_assignment__3 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__indexed_assignment__4" c_casadi__IMatrix__indexed_assignment__4 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr Slice' -> Ptr IMatrix' -> Ptr IMatrix' -> IO () casadi__IMatrix__indexed_assignment__4 :: IMatrix -> Slice -> IMatrix -> IMatrix -> IO () casadi__IMatrix__indexed_assignment__4 x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__indexed_assignment__4 errStrPtrP x0' x1' x2' x3' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_indexed_assignment__4 :: IMatrixClass a => a -> Slice -> IMatrix -> IMatrix -> IO () imatrix_indexed_assignment__4 x = casadi__IMatrix__indexed_assignment__4 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__indexed_assignment__5" c_casadi__IMatrix__indexed_assignment__5 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr Slice' -> Ptr Slice' -> Ptr IMatrix' -> IO () casadi__IMatrix__indexed_assignment__5 :: IMatrix -> Slice -> Slice -> IMatrix -> IO () casadi__IMatrix__indexed_assignment__5 x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__indexed_assignment__5 errStrPtrP x0' x1' x2' x3' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_indexed_assignment__5 :: IMatrixClass a => a -> Slice -> Slice -> IMatrix -> IO () imatrix_indexed_assignment__5 x = casadi__IMatrix__indexed_assignment__5 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__indexed_one_based__0" c_casadi__IMatrix__indexed_one_based__0 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> IO (Ptr IMatrix') casadi__IMatrix__indexed_one_based__0 :: IMatrix -> Int -> IO IMatrix casadi__IMatrix__indexed_one_based__0 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__indexed_one_based__0 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_indexed_one_based__0 :: IMatrixClass a => a -> Int -> IO IMatrix imatrix_indexed_one_based__0 x = casadi__IMatrix__indexed_one_based__0 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__indexed_one_based__1" c_casadi__IMatrix__indexed_one_based__1 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> CInt -> IO (Ptr IMatrix') casadi__IMatrix__indexed_one_based__1 :: IMatrix -> Int -> Int -> IO IMatrix casadi__IMatrix__indexed_one_based__1 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__indexed_one_based__1 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_indexed_one_based__1 :: IMatrixClass a => a -> Int -> Int -> IO IMatrix imatrix_indexed_one_based__1 x = casadi__IMatrix__indexed_one_based__1 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__indexed_one_based__2" c_casadi__IMatrix__indexed_one_based__2 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__indexed_one_based__2 :: IMatrix -> IMatrix -> IO IMatrix casadi__IMatrix__indexed_one_based__2 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__indexed_one_based__2 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_indexed_one_based__2 :: IMatrixClass a => a -> IMatrix -> IO IMatrix imatrix_indexed_one_based__2 x = casadi__IMatrix__indexed_one_based__2 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__indexed_one_based_assignment__0" c_casadi__IMatrix__indexed_one_based_assignment__0 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> CInt -> IO () casadi__IMatrix__indexed_one_based_assignment__0 :: IMatrix -> Int -> Int -> IO () casadi__IMatrix__indexed_one_based_assignment__0 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__indexed_one_based_assignment__0 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_indexed_one_based_assignment__0 :: IMatrixClass a => a -> Int -> Int -> IO () imatrix_indexed_one_based_assignment__0 x = casadi__IMatrix__indexed_one_based_assignment__0 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__indexed_one_based_assignment__1" c_casadi__IMatrix__indexed_one_based_assignment__1 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> CInt -> CInt -> IO () casadi__IMatrix__indexed_one_based_assignment__1 :: IMatrix -> Int -> Int -> Int -> IO () casadi__IMatrix__indexed_one_based_assignment__1 x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__indexed_one_based_assignment__1 errStrPtrP x0' x1' x2' x3' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_indexed_one_based_assignment__1 :: IMatrixClass a => a -> Int -> Int -> Int -> IO () imatrix_indexed_one_based_assignment__1 x = casadi__IMatrix__indexed_one_based_assignment__1 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__indexed_one_based_assignment__2" c_casadi__IMatrix__indexed_one_based_assignment__2 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> IO () casadi__IMatrix__indexed_one_based_assignment__2 :: IMatrix -> IMatrix -> IMatrix -> IO () casadi__IMatrix__indexed_one_based_assignment__2 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__indexed_one_based_assignment__2 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_indexed_one_based_assignment__2 :: IMatrixClass a => a -> IMatrix -> IMatrix -> IO () imatrix_indexed_one_based_assignment__2 x = casadi__IMatrix__indexed_one_based_assignment__2 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__indexed_zero_based__0" c_casadi__IMatrix__indexed_zero_based__0 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> IO (Ptr IMatrix') casadi__IMatrix__indexed_zero_based__0 :: IMatrix -> Int -> IO IMatrix casadi__IMatrix__indexed_zero_based__0 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__indexed_zero_based__0 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_indexed_zero_based__0 :: IMatrixClass a => a -> Int -> IO IMatrix imatrix_indexed_zero_based__0 x = casadi__IMatrix__indexed_zero_based__0 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__indexed_zero_based__1" c_casadi__IMatrix__indexed_zero_based__1 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> CInt -> IO (Ptr IMatrix') casadi__IMatrix__indexed_zero_based__1 :: IMatrix -> Int -> Int -> IO IMatrix casadi__IMatrix__indexed_zero_based__1 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__indexed_zero_based__1 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_indexed_zero_based__1 :: IMatrixClass a => a -> Int -> Int -> IO IMatrix imatrix_indexed_zero_based__1 x = casadi__IMatrix__indexed_zero_based__1 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__indexed_zero_based__2" c_casadi__IMatrix__indexed_zero_based__2 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__indexed_zero_based__2 :: IMatrix -> IMatrix -> IO IMatrix casadi__IMatrix__indexed_zero_based__2 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__indexed_zero_based__2 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_indexed_zero_based__2 :: IMatrixClass a => a -> IMatrix -> IO IMatrix imatrix_indexed_zero_based__2 x = casadi__IMatrix__indexed_zero_based__2 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__indexed_zero_based_assignment__0" c_casadi__IMatrix__indexed_zero_based_assignment__0 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> CInt -> IO () casadi__IMatrix__indexed_zero_based_assignment__0 :: IMatrix -> Int -> Int -> IO () casadi__IMatrix__indexed_zero_based_assignment__0 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__indexed_zero_based_assignment__0 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_indexed_zero_based_assignment__0 :: IMatrixClass a => a -> Int -> Int -> IO () imatrix_indexed_zero_based_assignment__0 x = casadi__IMatrix__indexed_zero_based_assignment__0 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__indexed_zero_based_assignment__1" c_casadi__IMatrix__indexed_zero_based_assignment__1 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> CInt -> CInt -> IO () casadi__IMatrix__indexed_zero_based_assignment__1 :: IMatrix -> Int -> Int -> Int -> IO () casadi__IMatrix__indexed_zero_based_assignment__1 x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__indexed_zero_based_assignment__1 errStrPtrP x0' x1' x2' x3' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_indexed_zero_based_assignment__1 :: IMatrixClass a => a -> Int -> Int -> Int -> IO () imatrix_indexed_zero_based_assignment__1 x = casadi__IMatrix__indexed_zero_based_assignment__1 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__indexed_zero_based_assignment__2" c_casadi__IMatrix__indexed_zero_based_assignment__2 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> IO () casadi__IMatrix__indexed_zero_based_assignment__2 :: IMatrix -> IMatrix -> IMatrix -> IO () casadi__IMatrix__indexed_zero_based_assignment__2 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__indexed_zero_based_assignment__2 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_indexed_zero_based_assignment__2 :: IMatrixClass a => a -> IMatrix -> IMatrix -> IO () imatrix_indexed_zero_based_assignment__2 x = casadi__IMatrix__indexed_zero_based_assignment__2 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__inf__0" c_casadi__IMatrix__inf__0 :: Ptr (Ptr StdString) -> IO (Ptr IMatrix') casadi__IMatrix__inf__0 :: IO IMatrix casadi__IMatrix__inf__0 = do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__inf__0 errStrPtrP errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_inf__0 :: IO IMatrix imatrix_inf__0 = casadi__IMatrix__inf__0 -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__inf__1" c_casadi__IMatrix__inf__1 :: Ptr (Ptr StdString) -> CInt -> IO (Ptr IMatrix') casadi__IMatrix__inf__1 :: Int -> IO IMatrix casadi__IMatrix__inf__1 x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__inf__1 errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_inf__1 :: Int -> IO IMatrix imatrix_inf__1 = casadi__IMatrix__inf__1 -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__inf__2" c_casadi__IMatrix__inf__2 :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr IMatrix') casadi__IMatrix__inf__2 :: Int -> Int -> IO IMatrix casadi__IMatrix__inf__2 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__inf__2 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_inf__2 :: Int -> Int -> IO IMatrix imatrix_inf__2 = casadi__IMatrix__inf__2 -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__inf__3" c_casadi__IMatrix__inf__3 :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr IMatrix') casadi__IMatrix__inf__3 :: Sparsity -> IO IMatrix casadi__IMatrix__inf__3 x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__inf__3 errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_inf__3 :: Sparsity -> IO IMatrix imatrix_inf__3 = casadi__IMatrix__inf__3 -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__isConstant" c_casadi__IMatrix__isConstant :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt casadi__IMatrix__isConstant :: IMatrix -> IO Bool casadi__IMatrix__isConstant x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__isConstant errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_isConstant :: IMatrixClass a => a -> IO Bool imatrix_isConstant x = casadi__IMatrix__isConstant (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__isDense" c_casadi__IMatrix__isDense :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt casadi__IMatrix__isDense :: IMatrix -> IO Bool casadi__IMatrix__isDense x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__isDense errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_isDense :: IMatrixClass a => a -> IO Bool imatrix_isDense x = casadi__IMatrix__isDense (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__isEmpty__0" c_casadi__IMatrix__isEmpty__0 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt casadi__IMatrix__isEmpty__0 :: IMatrix -> IO Bool casadi__IMatrix__isEmpty__0 x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__isEmpty__0 errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_isEmpty__0 :: IMatrixClass a => a -> IO Bool imatrix_isEmpty__0 x = casadi__IMatrix__isEmpty__0 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__isEmpty__1" c_casadi__IMatrix__isEmpty__1 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> IO CInt casadi__IMatrix__isEmpty__1 :: IMatrix -> Bool -> IO Bool casadi__IMatrix__isEmpty__1 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__isEmpty__1 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_isEmpty__1 :: IMatrixClass a => a -> Bool -> IO Bool imatrix_isEmpty__1 x = casadi__IMatrix__isEmpty__1 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__isEqual" c_casadi__IMatrix__isEqual :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO CInt casadi__IMatrix__isEqual :: IMatrix -> IMatrix -> IO Bool casadi__IMatrix__isEqual x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__isEqual errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_isEqual :: IMatrixClass a => a -> IMatrix -> IO Bool imatrix_isEqual x = casadi__IMatrix__isEqual (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__isIdentity" c_casadi__IMatrix__isIdentity :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt casadi__IMatrix__isIdentity :: IMatrix -> IO Bool casadi__IMatrix__isIdentity x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__isIdentity errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_isIdentity :: IMatrixClass a => a -> IO Bool imatrix_isIdentity x = casadi__IMatrix__isIdentity (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__isInteger" c_casadi__IMatrix__isInteger :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt casadi__IMatrix__isInteger :: IMatrix -> IO Bool casadi__IMatrix__isInteger x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__isInteger errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_isInteger :: IMatrixClass a => a -> IO Bool imatrix_isInteger x = casadi__IMatrix__isInteger (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__isMinusOne" c_casadi__IMatrix__isMinusOne :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt casadi__IMatrix__isMinusOne :: IMatrix -> IO Bool casadi__IMatrix__isMinusOne x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__isMinusOne errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_isMinusOne :: IMatrixClass a => a -> IO Bool imatrix_isMinusOne x = casadi__IMatrix__isMinusOne (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__isOne" c_casadi__IMatrix__isOne :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt casadi__IMatrix__isOne :: IMatrix -> IO Bool casadi__IMatrix__isOne x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__isOne errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_isOne :: IMatrixClass a => a -> IO Bool imatrix_isOne x = casadi__IMatrix__isOne (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__isRegular" c_casadi__IMatrix__isRegular :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt casadi__IMatrix__isRegular :: IMatrix -> IO Bool casadi__IMatrix__isRegular x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__isRegular errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_isRegular :: IMatrixClass a => a -> IO Bool imatrix_isRegular x = casadi__IMatrix__isRegular (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__isScalar__0" c_casadi__IMatrix__isScalar__0 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt casadi__IMatrix__isScalar__0 :: IMatrix -> IO Bool casadi__IMatrix__isScalar__0 x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__isScalar__0 errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_isScalar__0 :: IMatrixClass a => a -> IO Bool imatrix_isScalar__0 x = casadi__IMatrix__isScalar__0 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__isScalar__1" c_casadi__IMatrix__isScalar__1 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> IO CInt casadi__IMatrix__isScalar__1 :: IMatrix -> Bool -> IO Bool casadi__IMatrix__isScalar__1 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__isScalar__1 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_isScalar__1 :: IMatrixClass a => a -> Bool -> IO Bool imatrix_isScalar__1 x = casadi__IMatrix__isScalar__1 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__isSmooth" c_casadi__IMatrix__isSmooth :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt casadi__IMatrix__isSmooth :: IMatrix -> IO Bool casadi__IMatrix__isSmooth x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__isSmooth errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_isSmooth :: IMatrixClass a => a -> IO Bool imatrix_isSmooth x = casadi__IMatrix__isSmooth (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__isSquare" c_casadi__IMatrix__isSquare :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt casadi__IMatrix__isSquare :: IMatrix -> IO Bool casadi__IMatrix__isSquare x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__isSquare errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_isSquare :: IMatrixClass a => a -> IO Bool imatrix_isSquare x = casadi__IMatrix__isSquare (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__isSymbolic" c_casadi__IMatrix__isSymbolic :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt casadi__IMatrix__isSymbolic :: IMatrix -> IO Bool casadi__IMatrix__isSymbolic x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__isSymbolic errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_isSymbolic :: IMatrixClass a => a -> IO Bool imatrix_isSymbolic x = casadi__IMatrix__isSymbolic (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__isSymbolicSparse" c_casadi__IMatrix__isSymbolicSparse :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt casadi__IMatrix__isSymbolicSparse :: IMatrix -> IO Bool casadi__IMatrix__isSymbolicSparse x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__isSymbolicSparse errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_isSymbolicSparse :: IMatrixClass a => a -> IO Bool imatrix_isSymbolicSparse x = casadi__IMatrix__isSymbolicSparse (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__isTril" c_casadi__IMatrix__isTril :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt casadi__IMatrix__isTril :: IMatrix -> IO Bool casadi__IMatrix__isTril x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__isTril errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_isTril :: IMatrixClass a => a -> IO Bool imatrix_isTril x = casadi__IMatrix__isTril (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__isTriu" c_casadi__IMatrix__isTriu :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt casadi__IMatrix__isTriu :: IMatrix -> IO Bool casadi__IMatrix__isTriu x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__isTriu errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_isTriu :: IMatrixClass a => a -> IO Bool imatrix_isTriu x = casadi__IMatrix__isTriu (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__isVector" c_casadi__IMatrix__isVector :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt casadi__IMatrix__isVector :: IMatrix -> IO Bool casadi__IMatrix__isVector x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__isVector errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_isVector :: IMatrixClass a => a -> IO Bool imatrix_isVector x = casadi__IMatrix__isVector (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__isZero" c_casadi__IMatrix__isZero :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt casadi__IMatrix__isZero :: IMatrix -> IO Bool casadi__IMatrix__isZero x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__isZero errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_isZero :: IMatrixClass a => a -> IO Bool imatrix_isZero x = casadi__IMatrix__isZero (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__log" c_casadi__IMatrix__log :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__log :: IMatrix -> IO IMatrix casadi__IMatrix__log x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__log errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_log :: IMatrixClass a => a -> IO IMatrix imatrix_log x = casadi__IMatrix__log (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__log10" c_casadi__IMatrix__log10 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__log10 :: IMatrix -> IO IMatrix casadi__IMatrix__log10 x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__log10 errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_log10 :: IMatrixClass a => a -> IO IMatrix imatrix_log10 x = casadi__IMatrix__log10 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__logic_and" c_casadi__IMatrix__logic_and :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__logic_and :: IMatrix -> IMatrix -> IO IMatrix casadi__IMatrix__logic_and x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__logic_and errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_logic_and :: IMatrixClass a => a -> IMatrix -> IO IMatrix imatrix_logic_and x = casadi__IMatrix__logic_and (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__logic_not" c_casadi__IMatrix__logic_not :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__logic_not :: IMatrix -> IO IMatrix casadi__IMatrix__logic_not x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__logic_not errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_logic_not :: IMatrixClass a => a -> IO IMatrix imatrix_logic_not x = casadi__IMatrix__logic_not (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__logic_or" c_casadi__IMatrix__logic_or :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__logic_or :: IMatrix -> IMatrix -> IO IMatrix casadi__IMatrix__logic_or x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__logic_or errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_logic_or :: IMatrixClass a => a -> IMatrix -> IO IMatrix imatrix_logic_or x = casadi__IMatrix__logic_or (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__matrix_matrix" c_casadi__IMatrix__matrix_matrix :: Ptr (Ptr StdString) -> CInt -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__matrix_matrix :: Int -> IMatrix -> IMatrix -> IO IMatrix casadi__IMatrix__matrix_matrix x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__matrix_matrix errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_matrix_matrix :: Int -> IMatrix -> IMatrix -> IO IMatrix imatrix_matrix_matrix = casadi__IMatrix__matrix_matrix -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__matrix_scalar" c_casadi__IMatrix__matrix_scalar :: Ptr (Ptr StdString) -> CInt -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__matrix_scalar :: Int -> IMatrix -> IMatrix -> IO IMatrix casadi__IMatrix__matrix_scalar x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__matrix_scalar errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_matrix_scalar :: Int -> IMatrix -> IMatrix -> IO IMatrix imatrix_matrix_scalar = casadi__IMatrix__matrix_scalar -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__mul__0" c_casadi__IMatrix__mul__0 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__mul__0 :: IMatrix -> IMatrix -> IO IMatrix casadi__IMatrix__mul__0 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__mul__0 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_mul__0 :: IMatrixClass a => a -> IMatrix -> IO IMatrix imatrix_mul__0 x = casadi__IMatrix__mul__0 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__mul__1" c_casadi__IMatrix__mul__1 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr Sparsity' -> IO (Ptr IMatrix') casadi__IMatrix__mul__1 :: IMatrix -> IMatrix -> Sparsity -> IO IMatrix casadi__IMatrix__mul__1 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__mul__1 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_mul__1 :: IMatrixClass a => a -> IMatrix -> Sparsity -> IO IMatrix imatrix_mul__1 x = casadi__IMatrix__mul__1 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__mul_full__0" c_casadi__IMatrix__mul_full__0 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__mul_full__0 :: IMatrix -> IMatrix -> IO IMatrix casadi__IMatrix__mul_full__0 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__mul_full__0 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_mul_full__0 :: IMatrixClass a => a -> IMatrix -> IO IMatrix imatrix_mul_full__0 x = casadi__IMatrix__mul_full__0 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__mul_full__1" c_casadi__IMatrix__mul_full__1 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr Sparsity' -> IO (Ptr IMatrix') casadi__IMatrix__mul_full__1 :: IMatrix -> IMatrix -> Sparsity -> IO IMatrix casadi__IMatrix__mul_full__1 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__mul_full__1 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_mul_full__1 :: IMatrixClass a => a -> IMatrix -> Sparsity -> IO IMatrix imatrix_mul_full__1 x = casadi__IMatrix__mul_full__1 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__mul_no_alloc_nn__0" c_casadi__IMatrix__mul_no_alloc_nn__0 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO () casadi__IMatrix__mul_no_alloc_nn__0 :: IMatrix -> Vector Int -> Vector Int -> IO () casadi__IMatrix__mul_no_alloc_nn__0 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__mul_no_alloc_nn__0 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_mul_no_alloc_nn__0 :: IMatrix -> Vector Int -> Vector Int -> IO () imatrix_mul_no_alloc_nn__0 = casadi__IMatrix__mul_no_alloc_nn__0 -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__mul_no_alloc_nn__1" c_casadi__IMatrix__mul_no_alloc_nn__1 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> IO () casadi__IMatrix__mul_no_alloc_nn__1 :: IMatrix -> IMatrix -> IMatrix -> IO () casadi__IMatrix__mul_no_alloc_nn__1 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__mul_no_alloc_nn__1 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_mul_no_alloc_nn__1 :: IMatrix -> IMatrix -> IMatrix -> IO () imatrix_mul_no_alloc_nn__1 = casadi__IMatrix__mul_no_alloc_nn__1 -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__mul_no_alloc_nt" c_casadi__IMatrix__mul_no_alloc_nt :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> IO () casadi__IMatrix__mul_no_alloc_nt :: IMatrix -> IMatrix -> IMatrix -> IO () casadi__IMatrix__mul_no_alloc_nt x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__mul_no_alloc_nt errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_mul_no_alloc_nt :: IMatrix -> IMatrix -> IMatrix -> IO () imatrix_mul_no_alloc_nt = casadi__IMatrix__mul_no_alloc_nt -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__mul_no_alloc_tn__0" c_casadi__IMatrix__mul_no_alloc_tn__0 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO () casadi__IMatrix__mul_no_alloc_tn__0 :: IMatrix -> Vector Int -> Vector Int -> IO () casadi__IMatrix__mul_no_alloc_tn__0 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__mul_no_alloc_tn__0 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_mul_no_alloc_tn__0 :: IMatrix -> Vector Int -> Vector Int -> IO () imatrix_mul_no_alloc_tn__0 = casadi__IMatrix__mul_no_alloc_tn__0 -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__mul_no_alloc_tn__1" c_casadi__IMatrix__mul_no_alloc_tn__1 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> IO () casadi__IMatrix__mul_no_alloc_tn__1 :: IMatrix -> IMatrix -> IMatrix -> IO () casadi__IMatrix__mul_no_alloc_tn__1 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__mul_no_alloc_tn__1 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_mul_no_alloc_tn__1 :: IMatrix -> IMatrix -> IMatrix -> IO () imatrix_mul_no_alloc_tn__1 = casadi__IMatrix__mul_no_alloc_tn__1 -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__mul_smart" c_casadi__IMatrix__mul_smart :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr Sparsity' -> IO (Ptr IMatrix') casadi__IMatrix__mul_smart :: IMatrix -> IMatrix -> Sparsity -> IO IMatrix casadi__IMatrix__mul_smart x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__mul_smart errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_mul_smart :: IMatrixClass a => a -> IMatrix -> Sparsity -> IO IMatrix imatrix_mul_smart x = casadi__IMatrix__mul_smart (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__nan__0" c_casadi__IMatrix__nan__0 :: Ptr (Ptr StdString) -> IO (Ptr IMatrix') casadi__IMatrix__nan__0 :: IO IMatrix casadi__IMatrix__nan__0 = do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__nan__0 errStrPtrP errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_nan__0 :: IO IMatrix imatrix_nan__0 = casadi__IMatrix__nan__0 -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__nan__1" c_casadi__IMatrix__nan__1 :: Ptr (Ptr StdString) -> CInt -> IO (Ptr IMatrix') casadi__IMatrix__nan__1 :: Int -> IO IMatrix casadi__IMatrix__nan__1 x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__nan__1 errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_nan__1 :: Int -> IO IMatrix imatrix_nan__1 = casadi__IMatrix__nan__1 -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__nan__2" c_casadi__IMatrix__nan__2 :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr IMatrix') casadi__IMatrix__nan__2 :: Int -> Int -> IO IMatrix casadi__IMatrix__nan__2 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__nan__2 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_nan__2 :: Int -> Int -> IO IMatrix imatrix_nan__2 = casadi__IMatrix__nan__2 -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__nan__3" c_casadi__IMatrix__nan__3 :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr IMatrix') casadi__IMatrix__nan__3 :: Sparsity -> IO IMatrix casadi__IMatrix__nan__3 x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__nan__3 errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_nan__3 :: Sparsity -> IO IMatrix imatrix_nan__3 = casadi__IMatrix__nan__3 -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__numel" c_casadi__IMatrix__numel :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt casadi__IMatrix__numel :: IMatrix -> IO Int casadi__IMatrix__numel x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__numel errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_numel :: IMatrixClass a => a -> IO Int imatrix_numel x = casadi__IMatrix__numel (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__nz_indexed" c_casadi__IMatrix__nz_indexed :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr Slice' -> IO (Ptr IMatrix') casadi__IMatrix__nz_indexed :: IMatrix -> Slice -> IO IMatrix casadi__IMatrix__nz_indexed x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__nz_indexed errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_nz_indexed :: IMatrixClass a => a -> Slice -> IO IMatrix imatrix_nz_indexed x = casadi__IMatrix__nz_indexed (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__nz_indexed_assignment" c_casadi__IMatrix__nz_indexed_assignment :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr Slice' -> Ptr IMatrix' -> IO () casadi__IMatrix__nz_indexed_assignment :: IMatrix -> Slice -> IMatrix -> IO () casadi__IMatrix__nz_indexed_assignment x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__nz_indexed_assignment errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_nz_indexed_assignment :: IMatrixClass a => a -> Slice -> IMatrix -> IO () imatrix_nz_indexed_assignment x = casadi__IMatrix__nz_indexed_assignment (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__nz_indexed_one_based__0" c_casadi__IMatrix__nz_indexed_one_based__0 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__nz_indexed_one_based__0 :: IMatrix -> IMatrix -> IO IMatrix casadi__IMatrix__nz_indexed_one_based__0 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__nz_indexed_one_based__0 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_nz_indexed_one_based__0 :: IMatrixClass a => a -> IMatrix -> IO IMatrix imatrix_nz_indexed_one_based__0 x = casadi__IMatrix__nz_indexed_one_based__0 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__nz_indexed_one_based__1" c_casadi__IMatrix__nz_indexed_one_based__1 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> IO (Ptr IMatrix') casadi__IMatrix__nz_indexed_one_based__1 :: IMatrix -> Int -> IO IMatrix casadi__IMatrix__nz_indexed_one_based__1 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__nz_indexed_one_based__1 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_nz_indexed_one_based__1 :: IMatrixClass a => a -> Int -> IO IMatrix imatrix_nz_indexed_one_based__1 x = casadi__IMatrix__nz_indexed_one_based__1 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__nz_indexed_one_based_assignment__0" c_casadi__IMatrix__nz_indexed_one_based_assignment__0 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> IO () casadi__IMatrix__nz_indexed_one_based_assignment__0 :: IMatrix -> IMatrix -> IMatrix -> IO () casadi__IMatrix__nz_indexed_one_based_assignment__0 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__nz_indexed_one_based_assignment__0 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_nz_indexed_one_based_assignment__0 :: IMatrixClass a => a -> IMatrix -> IMatrix -> IO () imatrix_nz_indexed_one_based_assignment__0 x = casadi__IMatrix__nz_indexed_one_based_assignment__0 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__nz_indexed_one_based_assignment__1" c_casadi__IMatrix__nz_indexed_one_based_assignment__1 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> CInt -> IO () casadi__IMatrix__nz_indexed_one_based_assignment__1 :: IMatrix -> Int -> Int -> IO () casadi__IMatrix__nz_indexed_one_based_assignment__1 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__nz_indexed_one_based_assignment__1 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_nz_indexed_one_based_assignment__1 :: IMatrixClass a => a -> Int -> Int -> IO () imatrix_nz_indexed_one_based_assignment__1 x = casadi__IMatrix__nz_indexed_one_based_assignment__1 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__nz_indexed_zero_based__0" c_casadi__IMatrix__nz_indexed_zero_based__0 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__nz_indexed_zero_based__0 :: IMatrix -> IMatrix -> IO IMatrix casadi__IMatrix__nz_indexed_zero_based__0 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__nz_indexed_zero_based__0 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_nz_indexed_zero_based__0 :: IMatrixClass a => a -> IMatrix -> IO IMatrix imatrix_nz_indexed_zero_based__0 x = casadi__IMatrix__nz_indexed_zero_based__0 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__nz_indexed_zero_based__1" c_casadi__IMatrix__nz_indexed_zero_based__1 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> IO (Ptr IMatrix') casadi__IMatrix__nz_indexed_zero_based__1 :: IMatrix -> Int -> IO IMatrix casadi__IMatrix__nz_indexed_zero_based__1 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__nz_indexed_zero_based__1 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_nz_indexed_zero_based__1 :: IMatrixClass a => a -> Int -> IO IMatrix imatrix_nz_indexed_zero_based__1 x = casadi__IMatrix__nz_indexed_zero_based__1 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__nz_indexed_zero_based_assignment__0" c_casadi__IMatrix__nz_indexed_zero_based_assignment__0 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> IO () casadi__IMatrix__nz_indexed_zero_based_assignment__0 :: IMatrix -> IMatrix -> IMatrix -> IO () casadi__IMatrix__nz_indexed_zero_based_assignment__0 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__nz_indexed_zero_based_assignment__0 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_nz_indexed_zero_based_assignment__0 :: IMatrixClass a => a -> IMatrix -> IMatrix -> IO () imatrix_nz_indexed_zero_based_assignment__0 x = casadi__IMatrix__nz_indexed_zero_based_assignment__0 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__nz_indexed_zero_based_assignment__1" c_casadi__IMatrix__nz_indexed_zero_based_assignment__1 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> CInt -> IO () casadi__IMatrix__nz_indexed_zero_based_assignment__1 :: IMatrix -> Int -> Int -> IO () casadi__IMatrix__nz_indexed_zero_based_assignment__1 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__nz_indexed_zero_based_assignment__1 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_nz_indexed_zero_based_assignment__1 :: IMatrixClass a => a -> Int -> Int -> IO () imatrix_nz_indexed_zero_based_assignment__1 x = casadi__IMatrix__nz_indexed_zero_based_assignment__1 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__ones__0" c_casadi__IMatrix__ones__0 :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr IMatrix') casadi__IMatrix__ones__0 :: Sparsity -> IO IMatrix casadi__IMatrix__ones__0 x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__ones__0 errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_ones__0 :: Sparsity -> IO IMatrix imatrix_ones__0 = casadi__IMatrix__ones__0 -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__ones__1" c_casadi__IMatrix__ones__1 :: Ptr (Ptr StdString) -> IO (Ptr IMatrix') casadi__IMatrix__ones__1 :: IO IMatrix casadi__IMatrix__ones__1 = do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__ones__1 errStrPtrP errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_ones__1 :: IO IMatrix imatrix_ones__1 = casadi__IMatrix__ones__1 -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__ones__2" c_casadi__IMatrix__ones__2 :: Ptr (Ptr StdString) -> CInt -> IO (Ptr IMatrix') casadi__IMatrix__ones__2 :: Int -> IO IMatrix casadi__IMatrix__ones__2 x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__ones__2 errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_ones__2 :: Int -> IO IMatrix imatrix_ones__2 = casadi__IMatrix__ones__2 -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__ones__3" c_casadi__IMatrix__ones__3 :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr IMatrix') casadi__IMatrix__ones__3 :: Int -> Int -> IO IMatrix casadi__IMatrix__ones__3 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__ones__3 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_ones__3 :: Int -> Int -> IO IMatrix imatrix_ones__3 = casadi__IMatrix__ones__3 -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__printDense" c_casadi__IMatrix__printDense :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO () casadi__IMatrix__printDense :: IMatrix -> IO () casadi__IMatrix__printDense x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__printDense errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_printDense :: IMatrixClass a => a -> IO () imatrix_printDense x = casadi__IMatrix__printDense (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__printScalar" c_casadi__IMatrix__printScalar :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO () casadi__IMatrix__printScalar :: IMatrix -> IO () casadi__IMatrix__printScalar x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__printScalar errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_printScalar :: IMatrixClass a => a -> IO () imatrix_printScalar x = casadi__IMatrix__printScalar (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__printSparse" c_casadi__IMatrix__printSparse :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO () casadi__IMatrix__printSparse :: IMatrix -> IO () casadi__IMatrix__printSparse x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__printSparse errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_printSparse :: IMatrixClass a => a -> IO () imatrix_printSparse x = casadi__IMatrix__printSparse (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__printVector" c_casadi__IMatrix__printVector :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO () casadi__IMatrix__printVector :: IMatrix -> IO () casadi__IMatrix__printVector x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__printVector errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_printVector :: IMatrixClass a => a -> IO () imatrix_printVector x = casadi__IMatrix__printVector (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__printme" c_casadi__IMatrix__printme :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__printme :: IMatrix -> IMatrix -> IO IMatrix casadi__IMatrix__printme x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__printme errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_printme :: IMatrixClass a => a -> IMatrix -> IO IMatrix imatrix_printme x = casadi__IMatrix__printme (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__quad_form" c_casadi__IMatrix__quad_form :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec CInt) -> IO CInt casadi__IMatrix__quad_form :: IMatrix -> Vector Int -> IO Int casadi__IMatrix__quad_form x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__quad_form errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_quad_form :: IMatrix -> Vector Int -> IO Int imatrix_quad_form = casadi__IMatrix__quad_form -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__remove" c_casadi__IMatrix__remove :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO () casadi__IMatrix__remove :: IMatrix -> Vector Int -> Vector Int -> IO () casadi__IMatrix__remove x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__remove errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_remove :: IMatrixClass a => a -> Vector Int -> Vector Int -> IO () imatrix_remove x = casadi__IMatrix__remove (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__repmat__0" c_casadi__IMatrix__repmat__0 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> IO (Ptr IMatrix') casadi__IMatrix__repmat__0 :: IMatrix -> Int -> IO IMatrix casadi__IMatrix__repmat__0 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__repmat__0 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_repmat__0 :: IMatrix -> Int -> IO IMatrix imatrix_repmat__0 = casadi__IMatrix__repmat__0 -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__repmat__1" c_casadi__IMatrix__repmat__1 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> CInt -> IO (Ptr IMatrix') casadi__IMatrix__repmat__1 :: IMatrix -> Int -> Int -> IO IMatrix casadi__IMatrix__repmat__1 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__repmat__1 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_repmat__1 :: IMatrix -> Int -> Int -> IO IMatrix imatrix_repmat__1 = casadi__IMatrix__repmat__1 -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__repmat__2" c_casadi__IMatrix__repmat__2 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr Sparsity' -> IO (Ptr IMatrix') casadi__IMatrix__repmat__2 :: IMatrix -> Sparsity -> IO IMatrix casadi__IMatrix__repmat__2 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__repmat__2 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_repmat__2 :: IMatrix -> Sparsity -> IO IMatrix imatrix_repmat__2 = casadi__IMatrix__repmat__2 -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__repmat__3" c_casadi__IMatrix__repmat__3 :: Ptr (Ptr StdString) -> CInt -> Ptr Sparsity' -> IO (Ptr IMatrix') casadi__IMatrix__repmat__3 :: Int -> Sparsity -> IO IMatrix casadi__IMatrix__repmat__3 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__repmat__3 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_repmat__3 :: Int -> Sparsity -> IO IMatrix imatrix_repmat__3 = casadi__IMatrix__repmat__3 -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__reserve__0" c_casadi__IMatrix__reserve__0 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> CInt -> IO () casadi__IMatrix__reserve__0 :: IMatrix -> Int -> Int -> IO () casadi__IMatrix__reserve__0 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__reserve__0 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_reserve__0 :: IMatrixClass a => a -> Int -> Int -> IO () imatrix_reserve__0 x = casadi__IMatrix__reserve__0 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__reserve__1" c_casadi__IMatrix__reserve__1 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> IO () casadi__IMatrix__reserve__1 :: IMatrix -> Int -> IO () casadi__IMatrix__reserve__1 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__reserve__1 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_reserve__1 :: IMatrixClass a => a -> Int -> IO () imatrix_reserve__1 x = casadi__IMatrix__reserve__1 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__resize" c_casadi__IMatrix__resize :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> CInt -> IO () casadi__IMatrix__resize :: IMatrix -> Int -> Int -> IO () casadi__IMatrix__resize x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__resize errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_resize :: IMatrixClass a => a -> Int -> Int -> IO () imatrix_resize x = casadi__IMatrix__resize (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__row__0" c_casadi__IMatrix__row__0 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> IO CInt casadi__IMatrix__row__0 :: IMatrix -> Int -> IO Int casadi__IMatrix__row__0 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__row__0 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_row__0 :: IMatrixClass a => a -> Int -> IO Int imatrix_row__0 x = casadi__IMatrix__row__0 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__row__1" c_casadi__IMatrix__row__1 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr (StdVec CInt)) casadi__IMatrix__row__1 :: IMatrix -> IO (Vector Int) casadi__IMatrix__row__1 x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__row__1 errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_row__1 :: IMatrixClass a => a -> IO (Vector Int) imatrix_row__1 x = casadi__IMatrix__row__1 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__sanityCheck__0" c_casadi__IMatrix__sanityCheck__0 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO () casadi__IMatrix__sanityCheck__0 :: IMatrix -> IO () casadi__IMatrix__sanityCheck__0 x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__sanityCheck__0 errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_sanityCheck__0 :: IMatrixClass a => a -> IO () imatrix_sanityCheck__0 x = casadi__IMatrix__sanityCheck__0 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__sanityCheck__1" c_casadi__IMatrix__sanityCheck__1 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> IO () casadi__IMatrix__sanityCheck__1 :: IMatrix -> Bool -> IO () casadi__IMatrix__sanityCheck__1 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__sanityCheck__1 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_sanityCheck__1 :: IMatrixClass a => a -> Bool -> IO () imatrix_sanityCheck__1 x = casadi__IMatrix__sanityCheck__1 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__scalar_matrix" c_casadi__IMatrix__scalar_matrix :: Ptr (Ptr StdString) -> CInt -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__scalar_matrix :: Int -> IMatrix -> IMatrix -> IO IMatrix casadi__IMatrix__scalar_matrix x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__scalar_matrix errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_scalar_matrix :: Int -> IMatrix -> IMatrix -> IO IMatrix imatrix_scalar_matrix = casadi__IMatrix__scalar_matrix -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__set__0" c_casadi__IMatrix__set__0 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO () casadi__IMatrix__set__0 :: IMatrix -> IMatrix -> IO () casadi__IMatrix__set__0 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__set__0 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_set__0 :: IMatrixClass a => a -> IMatrix -> IO () imatrix_set__0 x = casadi__IMatrix__set__0 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__set__1" c_casadi__IMatrix__set__1 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> IO () casadi__IMatrix__set__1 :: IMatrix -> IMatrix -> SparsityType -> IO () casadi__IMatrix__set__1 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__set__1 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_set__1 :: IMatrixClass a => a -> IMatrix -> SparsityType -> IO () imatrix_set__1 x = casadi__IMatrix__set__1 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__set__2" c_casadi__IMatrix__set__2 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec CInt) -> IO () casadi__IMatrix__set__2 :: IMatrix -> Vector Int -> IO () casadi__IMatrix__set__2 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__set__2 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_set__2 :: IMatrixClass a => a -> Vector Int -> IO () imatrix_set__2 x = casadi__IMatrix__set__2 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__set__3" c_casadi__IMatrix__set__3 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec CInt) -> CInt -> IO () casadi__IMatrix__set__3 :: IMatrix -> Vector Int -> SparsityType -> IO () casadi__IMatrix__set__3 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__set__3 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_set__3 :: IMatrixClass a => a -> Vector Int -> SparsityType -> IO () imatrix_set__3 x = casadi__IMatrix__set__3 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__set__4" c_casadi__IMatrix__set__4 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> IO () casadi__IMatrix__set__4 :: IMatrix -> Int -> IO () casadi__IMatrix__set__4 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__set__4 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_set__4 :: IMatrixClass a => a -> Int -> IO () imatrix_set__4 x = casadi__IMatrix__set__4 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__set__5" c_casadi__IMatrix__set__5 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> CInt -> IO () casadi__IMatrix__set__5 :: IMatrix -> Int -> SparsityType -> IO () casadi__IMatrix__set__5 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__set__5 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_set__5 :: IMatrixClass a => a -> Int -> SparsityType -> IO () imatrix_set__5 x = casadi__IMatrix__set__5 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__setAll" c_casadi__IMatrix__setAll :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> IO () casadi__IMatrix__setAll :: IMatrix -> Int -> IO () casadi__IMatrix__setAll x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__setAll errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_setAll :: IMatrixClass a => a -> Int -> IO () imatrix_setAll x = casadi__IMatrix__setAll (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__setEqualityCheckingDepth__0" c_casadi__IMatrix__setEqualityCheckingDepth__0 :: Ptr (Ptr StdString) -> IO () casadi__IMatrix__setEqualityCheckingDepth__0 :: IO () casadi__IMatrix__setEqualityCheckingDepth__0 = do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__setEqualityCheckingDepth__0 errStrPtrP errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_setEqualityCheckingDepth__0 :: IO () imatrix_setEqualityCheckingDepth__0 = casadi__IMatrix__setEqualityCheckingDepth__0 -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__setEqualityCheckingDepth__1" c_casadi__IMatrix__setEqualityCheckingDepth__1 :: Ptr (Ptr StdString) -> CInt -> IO () casadi__IMatrix__setEqualityCheckingDepth__1 :: Int -> IO () casadi__IMatrix__setEqualityCheckingDepth__1 x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__setEqualityCheckingDepth__1 errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_setEqualityCheckingDepth__1 :: Int -> IO () imatrix_setEqualityCheckingDepth__1 = casadi__IMatrix__setEqualityCheckingDepth__1 -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__setMaxNumCallsInPrint__0" c_casadi__IMatrix__setMaxNumCallsInPrint__0 :: Ptr (Ptr StdString) -> IO () casadi__IMatrix__setMaxNumCallsInPrint__0 :: IO () casadi__IMatrix__setMaxNumCallsInPrint__0 = do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__setMaxNumCallsInPrint__0 errStrPtrP errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_setMaxNumCallsInPrint__0 :: IO () imatrix_setMaxNumCallsInPrint__0 = casadi__IMatrix__setMaxNumCallsInPrint__0 -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__setMaxNumCallsInPrint__1" c_casadi__IMatrix__setMaxNumCallsInPrint__1 :: Ptr (Ptr StdString) -> CLong -> IO () casadi__IMatrix__setMaxNumCallsInPrint__1 :: Int -> IO () casadi__IMatrix__setMaxNumCallsInPrint__1 x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__setMaxNumCallsInPrint__1 errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_setMaxNumCallsInPrint__1 :: Int -> IO () imatrix_setMaxNumCallsInPrint__1 = casadi__IMatrix__setMaxNumCallsInPrint__1 -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__setNZ__0" c_casadi__IMatrix__setNZ__0 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> IO () casadi__IMatrix__setNZ__0 :: IMatrix -> IMatrix -> IMatrix -> IO () casadi__IMatrix__setNZ__0 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__setNZ__0 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_setNZ__0 :: IMatrixClass a => a -> IMatrix -> IMatrix -> IO () imatrix_setNZ__0 x = casadi__IMatrix__setNZ__0 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__setNZ__1" c_casadi__IMatrix__setNZ__1 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr Slice' -> Ptr IMatrix' -> IO () casadi__IMatrix__setNZ__1 :: IMatrix -> Slice -> IMatrix -> IO () casadi__IMatrix__setNZ__1 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__setNZ__1 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_setNZ__1 :: IMatrixClass a => a -> Slice -> IMatrix -> IO () imatrix_setNZ__1 x = casadi__IMatrix__setNZ__1 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__setNZ__2" c_casadi__IMatrix__setNZ__2 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec CInt) -> Ptr IMatrix' -> IO () casadi__IMatrix__setNZ__2 :: IMatrix -> Vector Int -> IMatrix -> IO () casadi__IMatrix__setNZ__2 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__setNZ__2 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_setNZ__2 :: IMatrixClass a => a -> Vector Int -> IMatrix -> IO () imatrix_setNZ__2 x = casadi__IMatrix__setNZ__2 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__setNZ__3" c_casadi__IMatrix__setNZ__3 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> Ptr IMatrix' -> IO () casadi__IMatrix__setNZ__3 :: IMatrix -> Int -> IMatrix -> IO () casadi__IMatrix__setNZ__3 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__setNZ__3 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_setNZ__3 :: IMatrixClass a => a -> Int -> IMatrix -> IO () imatrix_setNZ__3 x = casadi__IMatrix__setNZ__3 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__setPrecision" c_casadi__IMatrix__setPrecision :: Ptr (Ptr StdString) -> CInt -> IO () casadi__IMatrix__setPrecision :: Int -> IO () casadi__IMatrix__setPrecision x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__setPrecision errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_setPrecision :: Int -> IO () imatrix_setPrecision = casadi__IMatrix__setPrecision -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__setScientific" c_casadi__IMatrix__setScientific :: Ptr (Ptr StdString) -> CInt -> IO () casadi__IMatrix__setScientific :: Bool -> IO () casadi__IMatrix__setScientific x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__setScientific errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_setScientific :: Bool -> IO () imatrix_setScientific = casadi__IMatrix__setScientific -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__setSparse__0" c_casadi__IMatrix__setSparse__0 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr Sparsity' -> IO (Ptr IMatrix') casadi__IMatrix__setSparse__0 :: IMatrix -> Sparsity -> IO IMatrix casadi__IMatrix__setSparse__0 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__setSparse__0 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_setSparse__0 :: IMatrixClass a => a -> Sparsity -> IO IMatrix imatrix_setSparse__0 x = casadi__IMatrix__setSparse__0 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__setSparse__1" c_casadi__IMatrix__setSparse__1 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr Sparsity' -> CInt -> IO (Ptr IMatrix') casadi__IMatrix__setSparse__1 :: IMatrix -> Sparsity -> Bool -> IO IMatrix casadi__IMatrix__setSparse__1 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__setSparse__1 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_setSparse__1 :: IMatrixClass a => a -> Sparsity -> Bool -> IO IMatrix imatrix_setSparse__1 x = casadi__IMatrix__setSparse__1 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__setSub__0" c_casadi__IMatrix__setSub__0 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr Sparsity' -> CInt -> IO () casadi__IMatrix__setSub__0 :: IMatrix -> IMatrix -> Sparsity -> Int -> IO () casadi__IMatrix__setSub__0 x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__setSub__0 errStrPtrP x0' x1' x2' x3' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_setSub__0 :: IMatrixClass a => a -> IMatrix -> Sparsity -> Int -> IO () imatrix_setSub__0 x = casadi__IMatrix__setSub__0 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__setSub__1" c_casadi__IMatrix__setSub__1 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> Ptr Slice' -> IO () casadi__IMatrix__setSub__1 :: IMatrix -> IMatrix -> Int -> Slice -> IO () casadi__IMatrix__setSub__1 x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__setSub__1 errStrPtrP x0' x1' x2' x3' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_setSub__1 :: IMatrixClass a => a -> IMatrix -> Int -> Slice -> IO () imatrix_setSub__1 x = casadi__IMatrix__setSub__1 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__setSub__2" c_casadi__IMatrix__setSub__2 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr Slice' -> CInt -> IO () casadi__IMatrix__setSub__2 :: IMatrix -> IMatrix -> Slice -> Int -> IO () casadi__IMatrix__setSub__2 x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__setSub__2 errStrPtrP x0' x1' x2' x3' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_setSub__2 :: IMatrixClass a => a -> IMatrix -> Slice -> Int -> IO () imatrix_setSub__2 x = casadi__IMatrix__setSub__2 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__setSub__3" c_casadi__IMatrix__setSub__3 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> IO () casadi__IMatrix__setSub__3 :: IMatrix -> IMatrix -> IMatrix -> IMatrix -> IO () casadi__IMatrix__setSub__3 x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__setSub__3 errStrPtrP x0' x1' x2' x3' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_setSub__3 :: IMatrixClass a => a -> IMatrix -> IMatrix -> IMatrix -> IO () imatrix_setSub__3 x = casadi__IMatrix__setSub__3 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__setSub__4" c_casadi__IMatrix__setSub__4 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr Slice' -> Ptr IMatrix' -> IO () casadi__IMatrix__setSub__4 :: IMatrix -> IMatrix -> Slice -> IMatrix -> IO () casadi__IMatrix__setSub__4 x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__setSub__4 errStrPtrP x0' x1' x2' x3' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_setSub__4 :: IMatrixClass a => a -> IMatrix -> Slice -> IMatrix -> IO () imatrix_setSub__4 x = casadi__IMatrix__setSub__4 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__setSub__5" c_casadi__IMatrix__setSub__5 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr Slice' -> IO () casadi__IMatrix__setSub__5 :: IMatrix -> IMatrix -> IMatrix -> Slice -> IO () casadi__IMatrix__setSub__5 x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__setSub__5 errStrPtrP x0' x1' x2' x3' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_setSub__5 :: IMatrixClass a => a -> IMatrix -> IMatrix -> Slice -> IO () imatrix_setSub__5 x = casadi__IMatrix__setSub__5 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__setSub__6" c_casadi__IMatrix__setSub__6 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> Ptr IMatrix' -> IO () casadi__IMatrix__setSub__6 :: IMatrix -> IMatrix -> Int -> IMatrix -> IO () casadi__IMatrix__setSub__6 x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__setSub__6 errStrPtrP x0' x1' x2' x3' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_setSub__6 :: IMatrixClass a => a -> IMatrix -> Int -> IMatrix -> IO () imatrix_setSub__6 x = casadi__IMatrix__setSub__6 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__setSub__7" c_casadi__IMatrix__setSub__7 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr (StdVec CInt) -> Ptr IMatrix' -> IO () casadi__IMatrix__setSub__7 :: IMatrix -> IMatrix -> Vector Int -> IMatrix -> IO () casadi__IMatrix__setSub__7 x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__setSub__7 errStrPtrP x0' x1' x2' x3' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_setSub__7 :: IMatrixClass a => a -> IMatrix -> Vector Int -> IMatrix -> IO () imatrix_setSub__7 x = casadi__IMatrix__setSub__7 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__setSub__8" c_casadi__IMatrix__setSub__8 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> IO () casadi__IMatrix__setSub__8 :: IMatrix -> IMatrix -> IMatrix -> Int -> IO () casadi__IMatrix__setSub__8 x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__setSub__8 errStrPtrP x0' x1' x2' x3' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_setSub__8 :: IMatrixClass a => a -> IMatrix -> IMatrix -> Int -> IO () imatrix_setSub__8 x = casadi__IMatrix__setSub__8 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__setSub__9" c_casadi__IMatrix__setSub__9 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr (StdVec CInt) -> IO () casadi__IMatrix__setSub__9 :: IMatrix -> IMatrix -> IMatrix -> Vector Int -> IO () casadi__IMatrix__setSub__9 x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__setSub__9 errStrPtrP x0' x1' x2' x3' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_setSub__9 :: IMatrixClass a => a -> IMatrix -> IMatrix -> Vector Int -> IO () imatrix_setSub__9 x = casadi__IMatrix__setSub__9 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__setSub__10" c_casadi__IMatrix__setSub__10 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr Slice' -> Ptr Slice' -> IO () casadi__IMatrix__setSub__10 :: IMatrix -> IMatrix -> Slice -> Slice -> IO () casadi__IMatrix__setSub__10 x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__setSub__10 errStrPtrP x0' x1' x2' x3' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_setSub__10 :: IMatrixClass a => a -> IMatrix -> Slice -> Slice -> IO () imatrix_setSub__10 x = casadi__IMatrix__setSub__10 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__setSub__11" c_casadi__IMatrix__setSub__11 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr (StdVec CInt) -> Ptr Slice' -> IO () casadi__IMatrix__setSub__11 :: IMatrix -> IMatrix -> Vector Int -> Slice -> IO () casadi__IMatrix__setSub__11 x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__setSub__11 errStrPtrP x0' x1' x2' x3' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_setSub__11 :: IMatrixClass a => a -> IMatrix -> Vector Int -> Slice -> IO () imatrix_setSub__11 x = casadi__IMatrix__setSub__11 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__setSub__12" c_casadi__IMatrix__setSub__12 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr Slice' -> Ptr (StdVec CInt) -> IO () casadi__IMatrix__setSub__12 :: IMatrix -> IMatrix -> Slice -> Vector Int -> IO () casadi__IMatrix__setSub__12 x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__setSub__12 errStrPtrP x0' x1' x2' x3' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_setSub__12 :: IMatrixClass a => a -> IMatrix -> Slice -> Vector Int -> IO () imatrix_setSub__12 x = casadi__IMatrix__setSub__12 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__setSub__13" c_casadi__IMatrix__setSub__13 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO () casadi__IMatrix__setSub__13 :: IMatrix -> IMatrix -> Vector Int -> Vector Int -> IO () casadi__IMatrix__setSub__13 x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__setSub__13 errStrPtrP x0' x1' x2' x3' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_setSub__13 :: IMatrixClass a => a -> IMatrix -> Vector Int -> Vector Int -> IO () imatrix_setSub__13 x = casadi__IMatrix__setSub__13 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__setSub__14" c_casadi__IMatrix__setSub__14 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> Ptr (StdVec CInt) -> IO () casadi__IMatrix__setSub__14 :: IMatrix -> IMatrix -> Int -> Vector Int -> IO () casadi__IMatrix__setSub__14 x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__setSub__14 errStrPtrP x0' x1' x2' x3' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_setSub__14 :: IMatrixClass a => a -> IMatrix -> Int -> Vector Int -> IO () imatrix_setSub__14 x = casadi__IMatrix__setSub__14 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__setSub__15" c_casadi__IMatrix__setSub__15 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr (StdVec CInt) -> CInt -> IO () casadi__IMatrix__setSub__15 :: IMatrix -> IMatrix -> Vector Int -> Int -> IO () casadi__IMatrix__setSub__15 x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__setSub__15 errStrPtrP x0' x1' x2' x3' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_setSub__15 :: IMatrixClass a => a -> IMatrix -> Vector Int -> Int -> IO () imatrix_setSub__15 x = casadi__IMatrix__setSub__15 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__setSub__16" c_casadi__IMatrix__setSub__16 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> CInt -> IO () casadi__IMatrix__setSub__16 :: IMatrix -> IMatrix -> Int -> Int -> IO () casadi__IMatrix__setSub__16 x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__setSub__16 errStrPtrP x0' x1' x2' x3' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_setSub__16 :: IMatrixClass a => a -> IMatrix -> Int -> Int -> IO () imatrix_setSub__16 x = casadi__IMatrix__setSub__16 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__setWidth" c_casadi__IMatrix__setWidth :: Ptr (Ptr StdString) -> CInt -> IO () casadi__IMatrix__setWidth :: Int -> IO () casadi__IMatrix__setWidth x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__setWidth errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_setWidth :: Int -> IO () imatrix_setWidth = casadi__IMatrix__setWidth -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__setZero" c_casadi__IMatrix__setZero :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO () casadi__IMatrix__setZero :: IMatrix -> IO () casadi__IMatrix__setZero x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__setZero errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_setZero :: IMatrixClass a => a -> IO () imatrix_setZero x = casadi__IMatrix__setZero (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__sign" c_casadi__IMatrix__sign :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__sign :: IMatrix -> IO IMatrix casadi__IMatrix__sign x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__sign errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_sign :: IMatrixClass a => a -> IO IMatrix imatrix_sign x = casadi__IMatrix__sign (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__sin" c_casadi__IMatrix__sin :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__sin :: IMatrix -> IO IMatrix casadi__IMatrix__sin x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__sin errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_sin :: IMatrixClass a => a -> IO IMatrix imatrix_sin x = casadi__IMatrix__sin (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__sinh" c_casadi__IMatrix__sinh :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__sinh :: IMatrix -> IO IMatrix casadi__IMatrix__sinh x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__sinh errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_sinh :: IMatrixClass a => a -> IO IMatrix imatrix_sinh x = casadi__IMatrix__sinh (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__size__0" c_casadi__IMatrix__size__0 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> IO CInt casadi__IMatrix__size__0 :: IMatrix -> SparsityType -> IO Int casadi__IMatrix__size__0 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__size__0 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_size__0 :: IMatrixClass a => a -> SparsityType -> IO Int imatrix_size__0 x = casadi__IMatrix__size__0 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__size__1" c_casadi__IMatrix__size__1 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt casadi__IMatrix__size__1 :: IMatrix -> IO Int casadi__IMatrix__size__1 x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__size__1 errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_size__1 :: IMatrixClass a => a -> IO Int imatrix_size__1 x = casadi__IMatrix__size__1 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__size1" c_casadi__IMatrix__size1 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt casadi__IMatrix__size1 :: IMatrix -> IO Int casadi__IMatrix__size1 x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__size1 errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_size1 :: IMatrixClass a => a -> IO Int imatrix_size1 x = casadi__IMatrix__size1 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__size2" c_casadi__IMatrix__size2 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt casadi__IMatrix__size2 :: IMatrix -> IO Int casadi__IMatrix__size2 x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__size2 errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_size2 :: IMatrixClass a => a -> IO Int imatrix_size2 x = casadi__IMatrix__size2 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__sizeD" c_casadi__IMatrix__sizeD :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt casadi__IMatrix__sizeD :: IMatrix -> IO Int casadi__IMatrix__sizeD x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__sizeD errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_sizeD :: IMatrixClass a => a -> IO Int imatrix_sizeD x = casadi__IMatrix__sizeD (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__sizeL" c_casadi__IMatrix__sizeL :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt casadi__IMatrix__sizeL :: IMatrix -> IO Int casadi__IMatrix__sizeL x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__sizeL errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_sizeL :: IMatrixClass a => a -> IO Int imatrix_sizeL x = casadi__IMatrix__sizeL (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__sizeU" c_casadi__IMatrix__sizeU :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt casadi__IMatrix__sizeU :: IMatrix -> IO Int casadi__IMatrix__sizeU x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__sizeU errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_sizeU :: IMatrixClass a => a -> IO Int imatrix_sizeU x = casadi__IMatrix__sizeU (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__sparse__0" c_casadi__IMatrix__sparse__0 :: Ptr (Ptr StdString) -> IO (Ptr IMatrix') casadi__IMatrix__sparse__0 :: IO IMatrix casadi__IMatrix__sparse__0 = do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__sparse__0 errStrPtrP errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_sparse__0 :: IO IMatrix imatrix_sparse__0 = casadi__IMatrix__sparse__0 -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__sparse__1" c_casadi__IMatrix__sparse__1 :: Ptr (Ptr StdString) -> CInt -> IO (Ptr IMatrix') casadi__IMatrix__sparse__1 :: Int -> IO IMatrix casadi__IMatrix__sparse__1 x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__sparse__1 errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_sparse__1 :: Int -> IO IMatrix imatrix_sparse__1 = casadi__IMatrix__sparse__1 -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__sparse__2" c_casadi__IMatrix__sparse__2 :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr IMatrix') casadi__IMatrix__sparse__2 :: Int -> Int -> IO IMatrix casadi__IMatrix__sparse__2 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__sparse__2 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_sparse__2 :: Int -> Int -> IO IMatrix imatrix_sparse__2 = casadi__IMatrix__sparse__2 -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__sparsify__0" c_casadi__IMatrix__sparsify__0 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO () casadi__IMatrix__sparsify__0 :: IMatrix -> IO () casadi__IMatrix__sparsify__0 x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__sparsify__0 errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_sparsify__0 :: IMatrixClass a => a -> IO () imatrix_sparsify__0 x = casadi__IMatrix__sparsify__0 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__sparsify__1" c_casadi__IMatrix__sparsify__1 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CDouble -> IO () casadi__IMatrix__sparsify__1 :: IMatrix -> Double -> IO () casadi__IMatrix__sparsify__1 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__sparsify__1 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_sparsify__1 :: IMatrixClass a => a -> Double -> IO () imatrix_sparsify__1 x = casadi__IMatrix__sparsify__1 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__sparsity__0" c_casadi__IMatrix__sparsity__0 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr Sparsity') casadi__IMatrix__sparsity__0 :: IMatrix -> IO Sparsity casadi__IMatrix__sparsity__0 x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__sparsity__0 errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_sparsity__0 :: IMatrixClass a => a -> IO Sparsity imatrix_sparsity__0 x = casadi__IMatrix__sparsity__0 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__sparsity__1" c_casadi__IMatrix__sparsity__1 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr Sparsity') casadi__IMatrix__sparsity__1 :: IMatrix -> IO Sparsity casadi__IMatrix__sparsity__1 x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__sparsity__1 errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_sparsity__1 :: IMatrixClass a => a -> IO Sparsity imatrix_sparsity__1 x = casadi__IMatrix__sparsity__1 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__sparsityRef__0" c_casadi__IMatrix__sparsityRef__0 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr Sparsity') casadi__IMatrix__sparsityRef__0 :: IMatrix -> IO Sparsity casadi__IMatrix__sparsityRef__0 x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__sparsityRef__0 errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_sparsityRef__0 :: IMatrixClass a => a -> IO Sparsity imatrix_sparsityRef__0 x = casadi__IMatrix__sparsityRef__0 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__sparsityRef__1" c_casadi__IMatrix__sparsityRef__1 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr Sparsity') casadi__IMatrix__sparsityRef__1 :: IMatrix -> IO Sparsity casadi__IMatrix__sparsityRef__1 x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__sparsityRef__1 errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_sparsityRef__1 :: IMatrixClass a => a -> IO Sparsity imatrix_sparsityRef__1 x = casadi__IMatrix__sparsityRef__1 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__sqrt" c_casadi__IMatrix__sqrt :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__sqrt :: IMatrix -> IO IMatrix casadi__IMatrix__sqrt x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__sqrt errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_sqrt :: IMatrixClass a => a -> IO IMatrix imatrix_sqrt x = casadi__IMatrix__sqrt (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__sub__0" c_casadi__IMatrix__sub__0 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr Sparsity' -> IO (Ptr IMatrix') casadi__IMatrix__sub__0 :: IMatrix -> Sparsity -> IO IMatrix casadi__IMatrix__sub__0 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__sub__0 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_sub__0 :: IMatrixClass a => a -> Sparsity -> IO IMatrix imatrix_sub__0 x = casadi__IMatrix__sub__0 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__sub__1" c_casadi__IMatrix__sub__1 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr Sparsity' -> CInt -> IO (Ptr IMatrix') casadi__IMatrix__sub__1 :: IMatrix -> Sparsity -> Int -> IO IMatrix casadi__IMatrix__sub__1 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__sub__1 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_sub__1 :: IMatrixClass a => a -> Sparsity -> Int -> IO IMatrix imatrix_sub__1 x = casadi__IMatrix__sub__1 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__sub__2" c_casadi__IMatrix__sub__2 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__sub__2 :: IMatrix -> IMatrix -> IMatrix -> IO IMatrix casadi__IMatrix__sub__2 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__sub__2 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_sub__2 :: IMatrixClass a => a -> IMatrix -> IMatrix -> IO IMatrix imatrix_sub__2 x = casadi__IMatrix__sub__2 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__sub__3" c_casadi__IMatrix__sub__3 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr Slice' -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__sub__3 :: IMatrix -> Slice -> IMatrix -> IO IMatrix casadi__IMatrix__sub__3 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__sub__3 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_sub__3 :: IMatrixClass a => a -> Slice -> IMatrix -> IO IMatrix imatrix_sub__3 x = casadi__IMatrix__sub__3 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__sub__4" c_casadi__IMatrix__sub__4 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr Slice' -> IO (Ptr IMatrix') casadi__IMatrix__sub__4 :: IMatrix -> IMatrix -> Slice -> IO IMatrix casadi__IMatrix__sub__4 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__sub__4 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_sub__4 :: IMatrixClass a => a -> IMatrix -> Slice -> IO IMatrix imatrix_sub__4 x = casadi__IMatrix__sub__4 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__sub__5" c_casadi__IMatrix__sub__5 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__sub__5 :: IMatrix -> Int -> IMatrix -> IO IMatrix casadi__IMatrix__sub__5 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__sub__5 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_sub__5 :: IMatrixClass a => a -> Int -> IMatrix -> IO IMatrix imatrix_sub__5 x = casadi__IMatrix__sub__5 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__sub__6" c_casadi__IMatrix__sub__6 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec CInt) -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__sub__6 :: IMatrix -> Vector Int -> IMatrix -> IO IMatrix casadi__IMatrix__sub__6 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__sub__6 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_sub__6 :: IMatrixClass a => a -> Vector Int -> IMatrix -> IO IMatrix imatrix_sub__6 x = casadi__IMatrix__sub__6 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__sub__7" c_casadi__IMatrix__sub__7 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> IO (Ptr IMatrix') casadi__IMatrix__sub__7 :: IMatrix -> IMatrix -> Int -> IO IMatrix casadi__IMatrix__sub__7 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__sub__7 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_sub__7 :: IMatrixClass a => a -> IMatrix -> Int -> IO IMatrix imatrix_sub__7 x = casadi__IMatrix__sub__7 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__sub__8" c_casadi__IMatrix__sub__8 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr (StdVec CInt) -> IO (Ptr IMatrix') casadi__IMatrix__sub__8 :: IMatrix -> IMatrix -> Vector Int -> IO IMatrix casadi__IMatrix__sub__8 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__sub__8 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_sub__8 :: IMatrixClass a => a -> IMatrix -> Vector Int -> IO IMatrix imatrix_sub__8 x = casadi__IMatrix__sub__8 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__sub__9" c_casadi__IMatrix__sub__9 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> Ptr Slice' -> IO (Ptr IMatrix') casadi__IMatrix__sub__9 :: IMatrix -> Int -> Slice -> IO IMatrix casadi__IMatrix__sub__9 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__sub__9 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_sub__9 :: IMatrixClass a => a -> Int -> Slice -> IO IMatrix imatrix_sub__9 x = casadi__IMatrix__sub__9 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__sub__10" c_casadi__IMatrix__sub__10 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr Slice' -> CInt -> IO (Ptr IMatrix') casadi__IMatrix__sub__10 :: IMatrix -> Slice -> Int -> IO IMatrix casadi__IMatrix__sub__10 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__sub__10 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_sub__10 :: IMatrixClass a => a -> Slice -> Int -> IO IMatrix imatrix_sub__10 x = casadi__IMatrix__sub__10 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__sub__11" c_casadi__IMatrix__sub__11 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr Slice' -> Ptr Slice' -> IO (Ptr IMatrix') casadi__IMatrix__sub__11 :: IMatrix -> Slice -> Slice -> IO IMatrix casadi__IMatrix__sub__11 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__sub__11 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_sub__11 :: IMatrixClass a => a -> Slice -> Slice -> IO IMatrix imatrix_sub__11 x = casadi__IMatrix__sub__11 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__sub__12" c_casadi__IMatrix__sub__12 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec CInt) -> Ptr Slice' -> IO (Ptr IMatrix') casadi__IMatrix__sub__12 :: IMatrix -> Vector Int -> Slice -> IO IMatrix casadi__IMatrix__sub__12 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__sub__12 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_sub__12 :: IMatrixClass a => a -> Vector Int -> Slice -> IO IMatrix imatrix_sub__12 x = casadi__IMatrix__sub__12 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__sub__13" c_casadi__IMatrix__sub__13 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr Slice' -> Ptr (StdVec CInt) -> IO (Ptr IMatrix') casadi__IMatrix__sub__13 :: IMatrix -> Slice -> Vector Int -> IO IMatrix casadi__IMatrix__sub__13 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__sub__13 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_sub__13 :: IMatrixClass a => a -> Slice -> Vector Int -> IO IMatrix imatrix_sub__13 x = casadi__IMatrix__sub__13 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__sub__14" c_casadi__IMatrix__sub__14 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO (Ptr IMatrix') casadi__IMatrix__sub__14 :: IMatrix -> Vector Int -> Vector Int -> IO IMatrix casadi__IMatrix__sub__14 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__sub__14 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_sub__14 :: IMatrixClass a => a -> Vector Int -> Vector Int -> IO IMatrix imatrix_sub__14 x = casadi__IMatrix__sub__14 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__sub__15" c_casadi__IMatrix__sub__15 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> Ptr (StdVec CInt) -> IO (Ptr IMatrix') casadi__IMatrix__sub__15 :: IMatrix -> Int -> Vector Int -> IO IMatrix casadi__IMatrix__sub__15 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__sub__15 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_sub__15 :: IMatrixClass a => a -> Int -> Vector Int -> IO IMatrix imatrix_sub__15 x = casadi__IMatrix__sub__15 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__sub__16" c_casadi__IMatrix__sub__16 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec CInt) -> CInt -> IO (Ptr IMatrix') casadi__IMatrix__sub__16 :: IMatrix -> Vector Int -> Int -> IO IMatrix casadi__IMatrix__sub__16 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__sub__16 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_sub__16 :: IMatrixClass a => a -> Vector Int -> Int -> IO IMatrix imatrix_sub__16 x = casadi__IMatrix__sub__16 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__sub__17" c_casadi__IMatrix__sub__17 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> CInt -> IO (Ptr IMatrix') casadi__IMatrix__sub__17 :: IMatrix -> Int -> Int -> IO IMatrix casadi__IMatrix__sub__17 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__sub__17 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_sub__17 :: IMatrixClass a => a -> Int -> Int -> IO IMatrix imatrix_sub__17 x = casadi__IMatrix__sub__17 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__sym__0" c_casadi__IMatrix__sym__0 :: Ptr (Ptr StdString) -> Ptr StdString -> CInt -> CInt -> CInt -> CInt -> IO (Ptr (StdVec (Ptr (StdVec (Ptr IMatrix'))))) casadi__IMatrix__sym__0 :: String -> Int -> Int -> Int -> Int -> IO (Vector (Vector IMatrix)) casadi__IMatrix__sym__0 x0 x1 x2 x3 x4 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> withMarshal x4 $ \x4' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__sym__0 errStrPtrP x0' x1' x2' x3' x4' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_sym__0 :: String -> Int -> Int -> Int -> Int -> IO (Vector (Vector IMatrix)) imatrix_sym__0 = casadi__IMatrix__sym__0 -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__sym__1" c_casadi__IMatrix__sym__1 :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> CInt -> CInt -> IO (Ptr (StdVec (Ptr (StdVec (Ptr IMatrix'))))) casadi__IMatrix__sym__1 :: String -> Sparsity -> Int -> Int -> IO (Vector (Vector IMatrix)) casadi__IMatrix__sym__1 x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__sym__1 errStrPtrP x0' x1' x2' x3' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_sym__1 :: String -> Sparsity -> Int -> Int -> IO (Vector (Vector IMatrix)) imatrix_sym__1 = casadi__IMatrix__sym__1 -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__sym__2" c_casadi__IMatrix__sym__2 :: Ptr (Ptr StdString) -> Ptr StdString -> CInt -> CInt -> CInt -> IO (Ptr (StdVec (Ptr IMatrix'))) casadi__IMatrix__sym__2 :: String -> Int -> Int -> Int -> IO (Vector IMatrix) casadi__IMatrix__sym__2 x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__sym__2 errStrPtrP x0' x1' x2' x3' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_sym__2 :: String -> Int -> Int -> Int -> IO (Vector IMatrix) imatrix_sym__2 = casadi__IMatrix__sym__2 -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__sym__3" c_casadi__IMatrix__sym__3 :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> CInt -> IO (Ptr (StdVec (Ptr IMatrix'))) casadi__IMatrix__sym__3 :: String -> Sparsity -> Int -> IO (Vector IMatrix) casadi__IMatrix__sym__3 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__sym__3 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_sym__3 :: String -> Sparsity -> Int -> IO (Vector IMatrix) imatrix_sym__3 = casadi__IMatrix__sym__3 -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__sym__4" c_casadi__IMatrix__sym__4 :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr IMatrix') casadi__IMatrix__sym__4 :: String -> Sparsity -> IO IMatrix casadi__IMatrix__sym__4 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__sym__4 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_sym__4 :: String -> Sparsity -> IO IMatrix imatrix_sym__4 = casadi__IMatrix__sym__4 -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__sym__5" c_casadi__IMatrix__sym__5 :: Ptr (Ptr StdString) -> Ptr StdString -> IO (Ptr IMatrix') casadi__IMatrix__sym__5 :: String -> IO IMatrix casadi__IMatrix__sym__5 x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__sym__5 errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_sym__5 :: String -> IO IMatrix imatrix_sym__5 = casadi__IMatrix__sym__5 -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__sym__6" c_casadi__IMatrix__sym__6 :: Ptr (Ptr StdString) -> Ptr StdString -> CInt -> IO (Ptr IMatrix') casadi__IMatrix__sym__6 :: String -> Int -> IO IMatrix casadi__IMatrix__sym__6 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__sym__6 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_sym__6 :: String -> Int -> IO IMatrix imatrix_sym__6 = casadi__IMatrix__sym__6 -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__sym__7" c_casadi__IMatrix__sym__7 :: Ptr (Ptr StdString) -> Ptr StdString -> CInt -> CInt -> IO (Ptr IMatrix') casadi__IMatrix__sym__7 :: String -> Int -> Int -> IO IMatrix casadi__IMatrix__sym__7 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__sym__7 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_sym__7 :: String -> Int -> Int -> IO IMatrix imatrix_sym__7 = casadi__IMatrix__sym__7 -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__tan" c_casadi__IMatrix__tan :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__tan :: IMatrix -> IO IMatrix casadi__IMatrix__tan x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__tan errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_tan :: IMatrixClass a => a -> IO IMatrix imatrix_tan x = casadi__IMatrix__tan (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__tanh" c_casadi__IMatrix__tanh :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__tanh :: IMatrix -> IO IMatrix casadi__IMatrix__tanh x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__tanh errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_tanh :: IMatrixClass a => a -> IO IMatrix imatrix_tanh x = casadi__IMatrix__tanh (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__toScalar" c_casadi__IMatrix__toScalar :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt casadi__IMatrix__toScalar :: IMatrix -> IO Int casadi__IMatrix__toScalar x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__toScalar errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_toScalar :: IMatrixClass a => a -> IO Int imatrix_toScalar x = casadi__IMatrix__toScalar (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__trans" c_casadi__IMatrix__trans :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__trans :: IMatrix -> IO IMatrix casadi__IMatrix__trans x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__trans errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_trans :: IMatrixClass a => a -> IO IMatrix imatrix_trans x = casadi__IMatrix__trans (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__triplet__0" c_casadi__IMatrix__triplet__0 :: Ptr (Ptr StdString) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> CInt -> CInt -> IO (Ptr IMatrix') casadi__IMatrix__triplet__0 :: Vector Int -> Vector Int -> Vector Int -> Int -> Int -> IO IMatrix casadi__IMatrix__triplet__0 x0 x1 x2 x3 x4 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> withMarshal x4 $ \x4' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__triplet__0 errStrPtrP x0' x1' x2' x3' x4' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_triplet__0 :: Vector Int -> Vector Int -> Vector Int -> Int -> Int -> IO IMatrix imatrix_triplet__0 = casadi__IMatrix__triplet__0 -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__triplet__1" c_casadi__IMatrix__triplet__1 :: Ptr (Ptr StdString) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO (Ptr IMatrix') casadi__IMatrix__triplet__1 :: Vector Int -> Vector Int -> Vector Int -> IO IMatrix casadi__IMatrix__triplet__1 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__triplet__1 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_triplet__1 :: Vector Int -> Vector Int -> Vector Int -> IO IMatrix imatrix_triplet__1 = casadi__IMatrix__triplet__1 -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__unary" c_casadi__IMatrix__unary :: Ptr (Ptr StdString) -> CInt -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__unary :: Int -> IMatrix -> IO IMatrix casadi__IMatrix__unary x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__unary errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_unary :: Int -> IMatrix -> IO IMatrix imatrix_unary = casadi__IMatrix__unary -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zeros__0" c_casadi__IMatrix__zeros__0 :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr IMatrix') casadi__IMatrix__zeros__0 :: Sparsity -> IO IMatrix casadi__IMatrix__zeros__0 x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zeros__0 errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zeros__0 :: Sparsity -> IO IMatrix imatrix_zeros__0 = casadi__IMatrix__zeros__0 -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zeros__1" c_casadi__IMatrix__zeros__1 :: Ptr (Ptr StdString) -> IO (Ptr IMatrix') casadi__IMatrix__zeros__1 :: IO IMatrix casadi__IMatrix__zeros__1 = do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zeros__1 errStrPtrP errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zeros__1 :: IO IMatrix imatrix_zeros__1 = casadi__IMatrix__zeros__1 -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zeros__2" c_casadi__IMatrix__zeros__2 :: Ptr (Ptr StdString) -> CInt -> IO (Ptr IMatrix') casadi__IMatrix__zeros__2 :: Int -> IO IMatrix casadi__IMatrix__zeros__2 x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zeros__2 errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zeros__2 :: Int -> IO IMatrix imatrix_zeros__2 = casadi__IMatrix__zeros__2 -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zeros__3" c_casadi__IMatrix__zeros__3 :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr IMatrix') casadi__IMatrix__zeros__3 :: Int -> Int -> IO IMatrix casadi__IMatrix__zeros__3 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zeros__3 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zeros__3 :: Int -> Int -> IO IMatrix imatrix_zeros__3 = casadi__IMatrix__zeros__3