{-# 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_T, imatrix__0, imatrix__1, imatrix__2, imatrix__3, imatrix__4, imatrix__5, imatrix__6, imatrix___constpow__, imatrix___copysign__, imatrix___mldivide__, imatrix___mrdivide__, imatrix___nonzero__, imatrix___truediv____0, imatrix___truediv____1, imatrix_append, imatrix_appendColumns, imatrix_binary, imatrix_className, imatrix_clear, imatrix_colind, imatrix_dimString, imatrix_enlarge__0, imatrix_enlarge__1, imatrix_erase__0, imatrix_erase__1, imatrix_erase__2, imatrix_erase__3, imatrix_eye, imatrix_find__0, imatrix_find__1, imatrix_getColind, imatrix_getDep__0, imatrix_getDep__1, imatrix_getDescription, imatrix_getElementHash, imatrix_getEqualityCheckingDepth, imatrix_getIntValue, imatrix_getMaxNumCallsInPrint, imatrix_getNZ__0, imatrix_getNZ__1, imatrix_getNZ__2, imatrix_getNZ__3, imatrix_getName, imatrix_getNdeps, imatrix_getRepresentation, imatrix_getRow, imatrix_getSparsity, imatrix_getSym, imatrix_getValue__0, imatrix_getValue__1, imatrix_get__0, imatrix_get__1, imatrix_get__10, imatrix_get__2, imatrix_get__3, imatrix_get__4, imatrix_get__5, imatrix_get__6, imatrix_get__7, imatrix_get__8, imatrix_get__9, imatrix_hasNZ, imatrix_hasNonStructuralZeros, imatrix_inf__0, imatrix_inf__1, imatrix_inf__2, imatrix_inf__3, imatrix_isCommutative, imatrix_isConstant, imatrix_isDense, imatrix_isEmpty__0, imatrix_isEmpty__1, imatrix_isIdentity, imatrix_isInteger, imatrix_isLeaf, imatrix_isMinusOne, imatrix_isOne, imatrix_isRegular, imatrix_isRowVector, imatrix_isScalar__0, imatrix_isScalar__1, imatrix_isSlice__0, imatrix_isSlice__1, imatrix_isSmooth, imatrix_isSquare, imatrix_isSymbolic, imatrix_isSymbolicSparse, imatrix_isTril, imatrix_isTriu, imatrix_isVector__0, imatrix_isVector__1, imatrix_isZero, imatrix_makeSparse__0, imatrix_makeSparse__1, imatrix_matrix_matrix, imatrix_matrix_scalar, imatrix_nan__0, imatrix_nan__1, imatrix_nan__2, imatrix_nan__3, imatrix_nnz, imatrix_nonzeros, imatrix_nonzeros_int, imatrix_numel__0, imatrix_numel__1, imatrix_ones__0, imatrix_ones__1, imatrix_ones__2, imatrix_ones__3, imatrix_operator_minus, imatrix_operator_plus, imatrix_printDense, imatrix_printScalar, imatrix_printSparse, imatrix_printVector, imatrix_printme, imatrix_remove, imatrix_reserve__0, imatrix_reserve__1, imatrix_resize, imatrix_row, imatrix_sanityCheck__0, imatrix_sanityCheck__1, imatrix_scalar_matrix, 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_setSym, imatrix_setValue__0, imatrix_setValue__1, imatrix_setWidth, imatrix_setZero, imatrix_set__0, imatrix_set__1, imatrix_set__10, imatrix_set__2, imatrix_set__3, imatrix_set__4, imatrix_set__5, imatrix_set__6, imatrix_set__7, imatrix_set__8, imatrix_set__9, 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_sparse__3, imatrix_sparsity, imatrix_sparsityRef, 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_toSlice__0, imatrix_toSlice__1, imatrix_triplet__0, imatrix_triplet__1, imatrix_unary, imatrix_zeros__0, imatrix_zeros__1, imatrix_zeros__2, imatrix_zeros__3, imatrix_zz_abs, imatrix_zz_acos, imatrix_zz_acosh, imatrix_zz_adj, imatrix_zz_all, imatrix_zz_and, imatrix_zz_any, imatrix_zz_asin, imatrix_zz_asinh, imatrix_zz_atan, imatrix_zz_atan2, imatrix_zz_atanh, imatrix_zz_blockcat, imatrix_zz_blocksplit, imatrix_zz_ceil, imatrix_zz_cofactor, imatrix_zz_cos, imatrix_zz_cosh, imatrix_zz_countNodes, imatrix_zz_cross__0, imatrix_zz_cross__1, imatrix_zz_densify, imatrix_zz_dependsOn, imatrix_zz_det, imatrix_zz_diag, imatrix_zz_diagcat, imatrix_zz_diagsplit, imatrix_zz_eig_symbolic, imatrix_zz_eq, imatrix_zz_erf, imatrix_zz_erfinv, imatrix_zz_exp, imatrix_zz_expand, imatrix_zz_extractShared__0, imatrix_zz_extractShared__1, imatrix_zz_extractShared__2, imatrix_zz_floor, imatrix_zz_gauss_quadrature__0, imatrix_zz_gauss_quadrature__1, imatrix_zz_gauss_quadrature__2, imatrix_zz_ge, imatrix_zz_getMinor, imatrix_zz_getOperatorRepresentation, imatrix_zz_getSymbols__0, imatrix_zz_getSymbols__1, imatrix_zz_gradient, imatrix_zz_gt, imatrix_zz_heaviside, imatrix_zz_hessian__0, imatrix_zz_hessian__1, imatrix_zz_horzcat, imatrix_zz_horzsplit, imatrix_zz_if_else, imatrix_zz_if_else_zero, imatrix_zz_inner_prod, imatrix_zz_inv, imatrix_zz_isEqual__0, imatrix_zz_isEqual__1, imatrix_zz_jacobian, imatrix_zz_jacobianTimesVector__0, imatrix_zz_jacobianTimesVector__1, imatrix_zz_kron, imatrix_zz_le, imatrix_zz_linspace, imatrix_zz_log, imatrix_zz_log10, imatrix_zz_lt, imatrix_zz_max, imatrix_zz_min, imatrix_zz_minus, imatrix_zz_mod, imatrix_zz_mpower, imatrix_zz_mtaylor__0, imatrix_zz_mtaylor__1, imatrix_zz_mtaylor__2, imatrix_zz_mtimes__0, imatrix_zz_mtimes__1, imatrix_zz_ne, imatrix_zz_norm_0_mul, imatrix_zz_norm_1, imatrix_zz_norm_2, imatrix_zz_norm_F, imatrix_zz_norm_inf, imatrix_zz_norm_inf_mul, imatrix_zz_not, imatrix_zz_nullspace, imatrix_zz_or, imatrix_zz_outer_prod, imatrix_zz_pinv, imatrix_zz_plus, imatrix_zz_poly_coeff, imatrix_zz_poly_roots, imatrix_zz_polyval, imatrix_zz_power, imatrix_zz_printCompact, imatrix_zz_project, imatrix_zz_pw_const, imatrix_zz_pw_lin, imatrix_zz_qr, imatrix_zz_quad_form__0, imatrix_zz_quad_form__1, imatrix_zz_quad_form__2, imatrix_zz_quad_form__3, imatrix_zz_ramp, imatrix_zz_rdivide, imatrix_zz_rectangle, imatrix_zz_repmat__0, imatrix_zz_repmat__1, imatrix_zz_reshape__0, imatrix_zz_reshape__1, imatrix_zz_sign, imatrix_zz_simplify, imatrix_zz_sin, imatrix_zz_sinh, imatrix_zz_solve, imatrix_zz_sparsify__0, imatrix_zz_sparsify__1, imatrix_zz_sprank, imatrix_zz_spy, imatrix_zz_sqrt, imatrix_zz_substituteInPlace__0, imatrix_zz_substituteInPlace__1, imatrix_zz_substitute__0, imatrix_zz_substitute__1, imatrix_zz_sumAll, imatrix_zz_sumCols, imatrix_zz_sumRows, imatrix_zz_sum_square, imatrix_zz_tan, imatrix_zz_tangent, imatrix_zz_tanh, imatrix_zz_taylor__0, imatrix_zz_taylor__1, imatrix_zz_taylor__2, imatrix_zz_times, imatrix_zz_trace, imatrix_zz_triangle, imatrix_zz_tril2symm, imatrix_zz_tril__0, imatrix_zz_tril__1, imatrix_zz_triu2symm, imatrix_zz_triu__0, imatrix_zz_triu__1, imatrix_zz_unite, imatrix_zz_vec, imatrix_zz_vecNZ, imatrix_zz_vecNZcat, imatrix_zz_veccat, imatrix_zz_vertcat, imatrix_zz_vertsplit, ) where import Prelude hiding ( Functor ) import Data.Vector ( Vector ) import Foreign.C.Types import Foreign.Marshal ( new, free ) import Foreign.Storable ( peek ) import Foreign.Ptr ( Ptr, nullPtr ) import Foreign.ForeignPtr ( newForeignPtr ) import System.IO.Unsafe ( unsafePerformIO ) -- for show instances import Casadi.Internal.CToolsInstances ( ) import Casadi.Internal.FormatException ( formatException ) import Casadi.Internal.MarshalTypes ( StdVec, StdString) -- StdPair StdOstream' import Casadi.Internal.Marshal ( Marshal(..), withMarshal ) import Casadi.Internal.WrapReturn ( WrapReturn(..) ) import Casadi.Core.Data import Casadi.Core.Enums -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__CONSTRUCTOR__0" c_casadi__IMatrix__CONSTRUCTOR__0 :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr (StdVec CDouble))) -> IO (Ptr IMatrix') casadi__IMatrix__CONSTRUCTOR__0 :: Vector (Vector Double) -> IO IMatrix casadi__IMatrix__CONSTRUCTOR__0 x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__CONSTRUCTOR__0 errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix__0 :: Vector (Vector Double) -> 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) -> CDouble -> IO (Ptr IMatrix') casadi__IMatrix__CONSTRUCTOR__1 :: Double -> 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 :: Double -> 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) -> Ptr Sparsity' -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__CONSTRUCTOR__2 :: Sparsity -> IMatrix -> IO IMatrix casadi__IMatrix__CONSTRUCTOR__2 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__CONSTRUCTOR__2 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix__2 :: Sparsity -> IMatrix -> 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' -> IO (Ptr IMatrix') casadi__IMatrix__CONSTRUCTOR__3 :: Sparsity -> IO IMatrix casadi__IMatrix__CONSTRUCTOR__3 x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__CONSTRUCTOR__3 errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix__3 :: Sparsity -> 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) -> CInt -> CInt -> IO (Ptr IMatrix') casadi__IMatrix__CONSTRUCTOR__4 :: Int -> Int -> IO IMatrix casadi__IMatrix__CONSTRUCTOR__4 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__CONSTRUCTOR__4 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix__4 :: Int -> Int -> 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 IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__CONSTRUCTOR__5 :: IMatrix -> IO IMatrix casadi__IMatrix__CONSTRUCTOR__5 x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__CONSTRUCTOR__5 errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix__5 :: IMatrix -> 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) -> IO (Ptr IMatrix') casadi__IMatrix__CONSTRUCTOR__6 :: IO IMatrix casadi__IMatrix__CONSTRUCTOR__6 = do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__CONSTRUCTOR__6 errStrPtrP errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix__6 :: IO IMatrix imatrix__6 = casadi__IMatrix__CONSTRUCTOR__6 -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__T" c_casadi__IMatrix__T :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__T :: IMatrix -> IO IMatrix casadi__IMatrix__T x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__T errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_T :: IMatrixClass a => a -> IO IMatrix imatrix_T x = casadi__IMatrix__T (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____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____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____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____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__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__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" c_casadi__IMatrix__colind :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> IO CInt casadi__IMatrix__colind :: IMatrix -> Int -> IO Int casadi__IMatrix__colind x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__colind errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_colind :: IMatrixClass a => a -> Int -> IO Int imatrix_colind x = casadi__IMatrix__colind (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__enlarge__0" c_casadi__IMatrix__enlarge__0 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> CInt -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO () casadi__IMatrix__enlarge__0 :: IMatrix -> Int -> Int -> Vector Int -> Vector Int -> IO () casadi__IMatrix__enlarge__0 x0 x1 x2 x3 x4 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> withMarshal x4 $ \x4' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__enlarge__0 errStrPtrP x0' x1' x2' x3' x4' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_enlarge__0 :: IMatrixClass a => a -> Int -> Int -> Vector Int -> Vector Int -> IO () imatrix_enlarge__0 x = casadi__IMatrix__enlarge__0 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__enlarge__1" c_casadi__IMatrix__enlarge__1 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> CInt -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> CInt -> IO () casadi__IMatrix__enlarge__1 :: IMatrix -> Int -> Int -> Vector Int -> Vector Int -> Bool -> IO () casadi__IMatrix__enlarge__1 x0 x1 x2 x3 x4 x5 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> withMarshal x4 $ \x4' -> withMarshal x5 $ \x5' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__enlarge__1 errStrPtrP x0' x1' x2' x3' x4' x5' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_enlarge__1 :: IMatrixClass a => a -> Int -> Int -> Vector Int -> Vector Int -> Bool -> IO () imatrix_enlarge__1 x = casadi__IMatrix__enlarge__1 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__erase__0" c_casadi__IMatrix__erase__0 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec CInt) -> IO () casadi__IMatrix__erase__0 :: IMatrix -> Vector Int -> IO () casadi__IMatrix__erase__0 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__erase__0 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_erase__0 :: IMatrixClass a => a -> Vector Int -> IO () imatrix_erase__0 x = casadi__IMatrix__erase__0 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__erase__1" c_casadi__IMatrix__erase__1 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec CInt) -> CInt -> IO () casadi__IMatrix__erase__1 :: IMatrix -> Vector Int -> Bool -> IO () casadi__IMatrix__erase__1 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__erase__1 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_erase__1 :: IMatrixClass a => a -> Vector Int -> Bool -> IO () imatrix_erase__1 x = casadi__IMatrix__erase__1 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__erase__2" c_casadi__IMatrix__erase__2 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO () casadi__IMatrix__erase__2 :: IMatrix -> Vector Int -> Vector Int -> IO () casadi__IMatrix__erase__2 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__erase__2 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_erase__2 :: IMatrixClass a => a -> Vector Int -> Vector Int -> IO () imatrix_erase__2 x = casadi__IMatrix__erase__2 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__erase__3" c_casadi__IMatrix__erase__3 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> CInt -> IO () casadi__IMatrix__erase__3 :: IMatrix -> Vector Int -> Vector Int -> Bool -> IO () casadi__IMatrix__erase__3 x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__erase__3 errStrPtrP x0' x1' x2' x3' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_erase__3 :: IMatrixClass a => a -> Vector Int -> Vector Int -> Bool -> IO () imatrix_erase__3 x = casadi__IMatrix__erase__3 (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__find__0" c_casadi__IMatrix__find__0 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr (StdVec CInt)) casadi__IMatrix__find__0 :: IMatrix -> IO (Vector Int) casadi__IMatrix__find__0 x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__find__0 errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_find__0 :: IMatrixClass a => a -> IO (Vector Int) imatrix_find__0 x = casadi__IMatrix__find__0 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__find__1" c_casadi__IMatrix__find__1 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> IO (Ptr (StdVec CInt)) casadi__IMatrix__find__1 :: IMatrix -> Bool -> IO (Vector Int) casadi__IMatrix__find__1 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__find__1 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_find__1 :: IMatrixClass a => a -> Bool -> IO (Vector Int) imatrix_find__1 x = casadi__IMatrix__find__1 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__get__0" c_casadi__IMatrix__get__0 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> Ptr IMatrix' -> Ptr IMatrix' -> IO () casadi__IMatrix__get__0 :: IMatrix -> IMatrix -> Bool -> IMatrix -> IMatrix -> IO () casadi__IMatrix__get__0 x0 x1 x2 x3 x4 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> withMarshal x4 $ \x4' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__get__0 errStrPtrP x0' x1' x2' x3' x4' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_get__0 :: IMatrixClass a => a -> IMatrix -> Bool -> IMatrix -> 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 -> Ptr IMatrix' -> Ptr Slice' -> IO () casadi__IMatrix__get__1 :: IMatrix -> IMatrix -> Bool -> IMatrix -> Slice -> IO () casadi__IMatrix__get__1 x0 x1 x2 x3 x4 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> withMarshal x4 $ \x4' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__get__1 errStrPtrP x0' x1' x2' x3' x4' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_get__1 :: IMatrixClass a => a -> IMatrix -> Bool -> IMatrix -> Slice -> 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 IMatrix' -> CInt -> Ptr Slice' -> Ptr IMatrix' -> IO () casadi__IMatrix__get__2 :: IMatrix -> IMatrix -> Bool -> Slice -> IMatrix -> IO () casadi__IMatrix__get__2 x0 x1 x2 x3 x4 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> withMarshal x4 $ \x4' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__get__2 errStrPtrP x0' x1' x2' x3' x4' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_get__2 :: IMatrixClass a => a -> IMatrix -> Bool -> Slice -> IMatrix -> 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 IMatrix' -> CInt -> Ptr Slice' -> Ptr Slice' -> IO () casadi__IMatrix__get__3 :: IMatrix -> IMatrix -> Bool -> Slice -> Slice -> IO () casadi__IMatrix__get__3 x0 x1 x2 x3 x4 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> withMarshal x4 $ \x4' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__get__3 errStrPtrP x0' x1' x2' x3' x4' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_get__3 :: IMatrixClass a => a -> IMatrix -> Bool -> Slice -> Slice -> 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' -> Ptr IMatrix' -> CInt -> Ptr Sparsity' -> IO () casadi__IMatrix__get__4 :: IMatrix -> IMatrix -> Bool -> Sparsity -> IO () casadi__IMatrix__get__4 x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__get__4 errStrPtrP x0' x1' x2' x3' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_get__4 :: IMatrixClass a => a -> IMatrix -> Bool -> Sparsity -> 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' -> Ptr IMatrix' -> CInt -> Ptr IMatrix' -> IO () casadi__IMatrix__get__5 :: IMatrix -> IMatrix -> Bool -> IMatrix -> IO () casadi__IMatrix__get__5 x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__get__5 errStrPtrP x0' x1' x2' x3' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_get__5 :: IMatrixClass a => a -> IMatrix -> Bool -> IMatrix -> IO () imatrix_get__5 x = casadi__IMatrix__get__5 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__get__6" c_casadi__IMatrix__get__6 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> Ptr Slice' -> IO () casadi__IMatrix__get__6 :: IMatrix -> IMatrix -> Bool -> Slice -> IO () casadi__IMatrix__get__6 x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__get__6 errStrPtrP x0' x1' x2' x3' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_get__6 :: IMatrixClass a => a -> IMatrix -> Bool -> Slice -> IO () imatrix_get__6 x = casadi__IMatrix__get__6 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__get__7" c_casadi__IMatrix__get__7 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec CDouble) -> IO () casadi__IMatrix__get__7 :: IMatrix -> Vector Double -> IO () casadi__IMatrix__get__7 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__get__7 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_get__7 :: IMatrixClass a => a -> Vector Double -> IO () imatrix_get__7 x = casadi__IMatrix__get__7 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__get__8" c_casadi__IMatrix__get__8 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec CDouble) -> CInt -> IO () casadi__IMatrix__get__8 :: IMatrix -> Vector Double -> Bool -> IO () casadi__IMatrix__get__8 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__get__8 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_get__8 :: IMatrixClass a => a -> Vector Double -> Bool -> IO () imatrix_get__8 x = casadi__IMatrix__get__8 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__get__9" c_casadi__IMatrix__get__9 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CDouble -> IO () casadi__IMatrix__get__9 :: IMatrix -> Double -> IO () casadi__IMatrix__get__9 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__get__9 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_get__9 :: IMatrixClass a => a -> Double -> IO () imatrix_get__9 x = casadi__IMatrix__get__9 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__get__10" c_casadi__IMatrix__get__10 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO () casadi__IMatrix__get__10 :: IMatrix -> IMatrix -> IO () casadi__IMatrix__get__10 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__get__10 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_get__10 :: IMatrixClass a => a -> IMatrix -> IO () imatrix_get__10 x = casadi__IMatrix__get__10 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__getColind" c_casadi__IMatrix__getColind :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr (StdVec CInt)) casadi__IMatrix__getColind :: IMatrix -> IO (Vector Int) casadi__IMatrix__getColind x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__getColind errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_getColind :: IMatrixClass a => a -> IO (Vector Int) imatrix_getColind x = casadi__IMatrix__getColind (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__getDep__0" c_casadi__IMatrix__getDep__0 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__getDep__0 :: IMatrix -> IO IMatrix casadi__IMatrix__getDep__0 x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__getDep__0 errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_getDep__0 :: IMatrixClass a => a -> IO IMatrix imatrix_getDep__0 x = casadi__IMatrix__getDep__0 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__getDep__1" c_casadi__IMatrix__getDep__1 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> IO (Ptr IMatrix') casadi__IMatrix__getDep__1 :: IMatrix -> Int -> IO IMatrix casadi__IMatrix__getDep__1 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__getDep__1 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_getDep__1 :: IMatrixClass a => a -> Int -> IO IMatrix imatrix_getDep__1 x = casadi__IMatrix__getDep__1 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__getElementHash" c_casadi__IMatrix__getElementHash :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CLong casadi__IMatrix__getElementHash :: IMatrix -> IO Int casadi__IMatrix__getElementHash x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__getElementHash errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_getElementHash :: IMatrixClass a => a -> IO Int imatrix_getElementHash x = casadi__IMatrix__getElementHash (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__getIntValue" c_casadi__IMatrix__getIntValue :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt casadi__IMatrix__getIntValue :: IMatrix -> IO Int casadi__IMatrix__getIntValue x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__getIntValue errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_getIntValue :: IMatrixClass a => a -> IO Int imatrix_getIntValue x = casadi__IMatrix__getIntValue (castIMatrix x) -- 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' -> CInt -> Ptr IMatrix' -> IO () casadi__IMatrix__getNZ__0 :: IMatrix -> IMatrix -> Bool -> IMatrix -> IO () casadi__IMatrix__getNZ__0 x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__getNZ__0 errStrPtrP x0' x1' x2' x3' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_getNZ__0 :: IMatrixClass a => a -> IMatrix -> Bool -> IMatrix -> IO () 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 IMatrix' -> CInt -> Ptr Slice' -> IO () casadi__IMatrix__getNZ__1 :: IMatrix -> IMatrix -> Bool -> Slice -> IO () casadi__IMatrix__getNZ__1 x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__getNZ__1 errStrPtrP x0' x1' x2' x3' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_getNZ__1 :: IMatrixClass a => a -> IMatrix -> Bool -> Slice -> IO () 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 CDouble) -> IO () casadi__IMatrix__getNZ__2 :: IMatrix -> Vector Double -> IO () 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 Double -> IO () 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' -> CDouble -> IO () casadi__IMatrix__getNZ__3 :: IMatrix -> Double -> IO () 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 -> Double -> IO () 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__getNdeps" c_casadi__IMatrix__getNdeps :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt casadi__IMatrix__getNdeps :: IMatrix -> IO Int casadi__IMatrix__getNdeps x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__getNdeps errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_getNdeps :: IMatrixClass a => a -> IO Int imatrix_getNdeps x = casadi__IMatrix__getNdeps (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__getRow" c_casadi__IMatrix__getRow :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr (StdVec CInt)) casadi__IMatrix__getRow :: IMatrix -> IO (Vector Int) casadi__IMatrix__getRow x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__getRow errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_getRow :: IMatrixClass a => a -> IO (Vector Int) imatrix_getRow x = casadi__IMatrix__getRow (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__getSparsity" c_casadi__IMatrix__getSparsity :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr Sparsity') casadi__IMatrix__getSparsity :: IMatrix -> IO Sparsity casadi__IMatrix__getSparsity x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__getSparsity errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_getSparsity :: IMatrixClass a => a -> IO Sparsity imatrix_getSparsity x = casadi__IMatrix__getSparsity (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__getSym" c_casadi__IMatrix__getSym :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec CDouble) -> IO () casadi__IMatrix__getSym :: IMatrix -> Vector Double -> IO () casadi__IMatrix__getSym x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__getSym errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_getSym :: IMatrixClass a => a -> Vector Double -> IO () imatrix_getSym x = casadi__IMatrix__getSym (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__getValue__0" c_casadi__IMatrix__getValue__0 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> IO CDouble casadi__IMatrix__getValue__0 :: IMatrix -> Int -> IO Double casadi__IMatrix__getValue__0 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__getValue__0 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_getValue__0 :: IMatrixClass a => a -> Int -> IO Double imatrix_getValue__0 x = casadi__IMatrix__getValue__0 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__getValue__1" c_casadi__IMatrix__getValue__1 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CDouble casadi__IMatrix__getValue__1 :: IMatrix -> IO Double casadi__IMatrix__getValue__1 x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__getValue__1 errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_getValue__1 :: IMatrixClass a => a -> IO Double imatrix_getValue__1 x = casadi__IMatrix__getValue__1 (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__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__isCommutative" c_casadi__IMatrix__isCommutative :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt casadi__IMatrix__isCommutative :: IMatrix -> IO Bool casadi__IMatrix__isCommutative x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__isCommutative errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_isCommutative :: IMatrixClass a => a -> IO Bool imatrix_isCommutative x = casadi__IMatrix__isCommutative (castIMatrix x) -- 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__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__isLeaf" c_casadi__IMatrix__isLeaf :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt casadi__IMatrix__isLeaf :: IMatrix -> IO Bool casadi__IMatrix__isLeaf x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__isLeaf errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_isLeaf :: IMatrixClass a => a -> IO Bool imatrix_isLeaf x = casadi__IMatrix__isLeaf (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__isRowVector" c_casadi__IMatrix__isRowVector :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt casadi__IMatrix__isRowVector :: IMatrix -> IO Bool casadi__IMatrix__isRowVector x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__isRowVector errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_isRowVector :: IMatrixClass a => a -> IO Bool imatrix_isRowVector x = casadi__IMatrix__isRowVector (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__isSlice__0" c_casadi__IMatrix__isSlice__0 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt casadi__IMatrix__isSlice__0 :: IMatrix -> IO Bool casadi__IMatrix__isSlice__0 x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__isSlice__0 errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_isSlice__0 :: IMatrixClass a => a -> IO Bool imatrix_isSlice__0 x = casadi__IMatrix__isSlice__0 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__isSlice__1" c_casadi__IMatrix__isSlice__1 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> IO CInt casadi__IMatrix__isSlice__1 :: IMatrix -> Bool -> IO Bool casadi__IMatrix__isSlice__1 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__isSlice__1 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_isSlice__1 :: IMatrixClass a => a -> Bool -> IO Bool imatrix_isSlice__1 x = casadi__IMatrix__isSlice__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__0" c_casadi__IMatrix__isVector__0 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt casadi__IMatrix__isVector__0 :: IMatrix -> IO Bool casadi__IMatrix__isVector__0 x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__isVector__0 errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_isVector__0 :: IMatrixClass a => a -> IO Bool imatrix_isVector__0 x = casadi__IMatrix__isVector__0 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__isVector__1" c_casadi__IMatrix__isVector__1 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> IO CInt casadi__IMatrix__isVector__1 :: IMatrix -> Bool -> IO Bool casadi__IMatrix__isVector__1 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__isVector__1 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_isVector__1 :: IMatrixClass a => a -> Bool -> IO Bool imatrix_isVector__1 x = casadi__IMatrix__isVector__1 (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__makeSparse__0" c_casadi__IMatrix__makeSparse__0 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO () casadi__IMatrix__makeSparse__0 :: IMatrix -> IO () casadi__IMatrix__makeSparse__0 x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__makeSparse__0 errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_makeSparse__0 :: IMatrixClass a => a -> IO () imatrix_makeSparse__0 x = casadi__IMatrix__makeSparse__0 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__makeSparse__1" c_casadi__IMatrix__makeSparse__1 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CDouble -> IO () casadi__IMatrix__makeSparse__1 :: IMatrix -> Double -> IO () casadi__IMatrix__makeSparse__1 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__makeSparse__1 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_makeSparse__1 :: IMatrixClass a => a -> Double -> IO () imatrix_makeSparse__1 x = casadi__IMatrix__makeSparse__1 (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__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__nnz" c_casadi__IMatrix__nnz :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt casadi__IMatrix__nnz :: IMatrix -> IO Int casadi__IMatrix__nnz x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__nnz errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_nnz :: IMatrixClass a => a -> IO Int imatrix_nnz x = casadi__IMatrix__nnz (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__nonzeros" c_casadi__IMatrix__nonzeros :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr (StdVec CDouble)) casadi__IMatrix__nonzeros :: IMatrix -> IO (Vector Double) casadi__IMatrix__nonzeros x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__nonzeros errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_nonzeros :: IMatrixClass a => a -> IO (Vector Double) imatrix_nonzeros x = casadi__IMatrix__nonzeros (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__nonzeros_int" c_casadi__IMatrix__nonzeros_int :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr (StdVec CInt)) casadi__IMatrix__nonzeros_int :: IMatrix -> IO (Vector Int) casadi__IMatrix__nonzeros_int x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__nonzeros_int errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_nonzeros_int :: IMatrixClass a => a -> IO (Vector Int) imatrix_nonzeros_int x = casadi__IMatrix__nonzeros_int (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__numel__0" c_casadi__IMatrix__numel__0 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> IO CInt casadi__IMatrix__numel__0 :: IMatrix -> Int -> IO Int casadi__IMatrix__numel__0 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__numel__0 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_numel__0 :: IMatrixClass a => a -> Int -> IO Int imatrix_numel__0 x = casadi__IMatrix__numel__0 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__numel__1" c_casadi__IMatrix__numel__1 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt casadi__IMatrix__numel__1 :: IMatrix -> IO Int casadi__IMatrix__numel__1 x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__numel__1 errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_numel__1 :: IMatrixClass a => a -> IO Int imatrix_numel__1 x = casadi__IMatrix__numel__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__operator_plus" c_casadi__IMatrix__operator_plus :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__operator_plus :: IMatrix -> IO IMatrix casadi__IMatrix__operator_plus x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__operator_plus errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_operator_plus :: IMatrixClass a => a -> IO IMatrix imatrix_operator_plus x = casadi__IMatrix__operator_plus (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__operator_minus" c_casadi__IMatrix__operator_minus :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__operator_minus :: IMatrix -> IO IMatrix casadi__IMatrix__operator_minus x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__operator_minus errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_operator_minus :: IMatrixClass a => a -> IO IMatrix imatrix_operator_minus x = casadi__IMatrix__operator_minus (castIMatrix x) -- 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__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__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" c_casadi__IMatrix__row :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> IO CInt casadi__IMatrix__row :: IMatrix -> Int -> IO Int casadi__IMatrix__row x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__row errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_row :: IMatrixClass a => a -> Int -> IO Int imatrix_row x = casadi__IMatrix__row (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' -> CInt -> Ptr IMatrix' -> Ptr IMatrix' -> IO () casadi__IMatrix__set__0 :: IMatrix -> IMatrix -> Bool -> IMatrix -> IMatrix -> IO () casadi__IMatrix__set__0 x0 x1 x2 x3 x4 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> withMarshal x4 $ \x4' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__set__0 errStrPtrP x0' x1' x2' x3' x4' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_set__0 :: IMatrixClass a => a -> IMatrix -> Bool -> IMatrix -> 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 -> Ptr IMatrix' -> Ptr Slice' -> IO () casadi__IMatrix__set__1 :: IMatrix -> IMatrix -> Bool -> IMatrix -> Slice -> IO () casadi__IMatrix__set__1 x0 x1 x2 x3 x4 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> withMarshal x4 $ \x4' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__set__1 errStrPtrP x0' x1' x2' x3' x4' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_set__1 :: IMatrixClass a => a -> IMatrix -> Bool -> IMatrix -> Slice -> 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 IMatrix' -> CInt -> Ptr Slice' -> Ptr IMatrix' -> IO () casadi__IMatrix__set__2 :: IMatrix -> IMatrix -> Bool -> Slice -> IMatrix -> IO () casadi__IMatrix__set__2 x0 x1 x2 x3 x4 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> withMarshal x4 $ \x4' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__set__2 errStrPtrP x0' x1' x2' x3' x4' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_set__2 :: IMatrixClass a => a -> IMatrix -> Bool -> Slice -> IMatrix -> 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 IMatrix' -> CInt -> Ptr Slice' -> Ptr Slice' -> IO () casadi__IMatrix__set__3 :: IMatrix -> IMatrix -> Bool -> Slice -> Slice -> IO () casadi__IMatrix__set__3 x0 x1 x2 x3 x4 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> withMarshal x4 $ \x4' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__set__3 errStrPtrP x0' x1' x2' x3' x4' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_set__3 :: IMatrixClass a => a -> IMatrix -> Bool -> Slice -> Slice -> 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' -> Ptr IMatrix' -> CInt -> Ptr Sparsity' -> IO () casadi__IMatrix__set__4 :: IMatrix -> IMatrix -> Bool -> Sparsity -> IO () casadi__IMatrix__set__4 x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__set__4 errStrPtrP x0' x1' x2' x3' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_set__4 :: IMatrixClass a => a -> IMatrix -> Bool -> Sparsity -> 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' -> Ptr IMatrix' -> CInt -> Ptr IMatrix' -> IO () casadi__IMatrix__set__5 :: IMatrix -> IMatrix -> Bool -> IMatrix -> IO () casadi__IMatrix__set__5 x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__set__5 errStrPtrP x0' x1' x2' x3' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_set__5 :: IMatrixClass a => a -> IMatrix -> Bool -> IMatrix -> IO () imatrix_set__5 x = casadi__IMatrix__set__5 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__set__6" c_casadi__IMatrix__set__6 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> Ptr Slice' -> IO () casadi__IMatrix__set__6 :: IMatrix -> IMatrix -> Bool -> Slice -> IO () casadi__IMatrix__set__6 x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__set__6 errStrPtrP x0' x1' x2' x3' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_set__6 :: IMatrixClass a => a -> IMatrix -> Bool -> Slice -> IO () imatrix_set__6 x = casadi__IMatrix__set__6 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__set__7" c_casadi__IMatrix__set__7 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec CDouble) -> IO () casadi__IMatrix__set__7 :: IMatrix -> Vector Double -> IO () casadi__IMatrix__set__7 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__set__7 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_set__7 :: IMatrixClass a => a -> Vector Double -> IO () imatrix_set__7 x = casadi__IMatrix__set__7 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__set__8" c_casadi__IMatrix__set__8 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec CDouble) -> CInt -> IO () casadi__IMatrix__set__8 :: IMatrix -> Vector Double -> Bool -> IO () casadi__IMatrix__set__8 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__set__8 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_set__8 :: IMatrixClass a => a -> Vector Double -> Bool -> IO () imatrix_set__8 x = casadi__IMatrix__set__8 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__set__9" c_casadi__IMatrix__set__9 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CDouble -> IO () casadi__IMatrix__set__9 :: IMatrix -> Double -> IO () casadi__IMatrix__set__9 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__set__9 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_set__9 :: IMatrixClass a => a -> Double -> IO () imatrix_set__9 x = casadi__IMatrix__set__9 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__set__10" c_casadi__IMatrix__set__10 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO () casadi__IMatrix__set__10 :: IMatrix -> IMatrix -> IO () casadi__IMatrix__set__10 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__set__10 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_set__10 :: IMatrixClass a => a -> IMatrix -> IO () imatrix_set__10 x = casadi__IMatrix__set__10 (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' -> CInt -> Ptr IMatrix' -> IO () casadi__IMatrix__setNZ__0 :: IMatrix -> IMatrix -> Bool -> IMatrix -> IO () casadi__IMatrix__setNZ__0 x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__setNZ__0 errStrPtrP x0' x1' x2' x3' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_setNZ__0 :: IMatrixClass a => a -> IMatrix -> Bool -> 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 IMatrix' -> CInt -> Ptr Slice' -> IO () casadi__IMatrix__setNZ__1 :: IMatrix -> IMatrix -> Bool -> Slice -> IO () casadi__IMatrix__setNZ__1 x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__setNZ__1 errStrPtrP x0' x1' x2' x3' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_setNZ__1 :: IMatrixClass a => a -> IMatrix -> Bool -> Slice -> 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 CDouble) -> IO () casadi__IMatrix__setNZ__2 :: IMatrix -> Vector Double -> IO () casadi__IMatrix__setNZ__2 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__setNZ__2 errStrPtrP x0' x1' 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 Double -> 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' -> CDouble -> IO () casadi__IMatrix__setNZ__3 :: IMatrix -> Double -> IO () casadi__IMatrix__setNZ__3 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__setNZ__3 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_setNZ__3 :: IMatrixClass a => a -> Double -> 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__setSym" c_casadi__IMatrix__setSym :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec CDouble) -> IO () casadi__IMatrix__setSym :: IMatrix -> Vector Double -> IO () casadi__IMatrix__setSym x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__setSym errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_setSym :: IMatrixClass a => a -> Vector Double -> IO () imatrix_setSym x = casadi__IMatrix__setSym (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__setValue__0" c_casadi__IMatrix__setValue__0 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CDouble -> CInt -> IO () casadi__IMatrix__setValue__0 :: IMatrix -> Double -> Int -> IO () casadi__IMatrix__setValue__0 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__setValue__0 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_setValue__0 :: IMatrixClass a => a -> Double -> Int -> IO () imatrix_setValue__0 x = casadi__IMatrix__setValue__0 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__setValue__1" c_casadi__IMatrix__setValue__1 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CDouble -> IO () casadi__IMatrix__setValue__1 :: IMatrix -> Double -> IO () casadi__IMatrix__setValue__1 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__setValue__1 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_setValue__1 :: IMatrixClass a => a -> Double -> IO () imatrix_setValue__1 x = casadi__IMatrix__setValue__1 (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__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) -> Ptr Sparsity' -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__sparse__0 :: Sparsity -> IMatrix -> IO IMatrix casadi__IMatrix__sparse__0 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__sparse__0 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_sparse__0 :: Sparsity -> IMatrix -> 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) -> IO (Ptr IMatrix') casadi__IMatrix__sparse__1 :: IO IMatrix casadi__IMatrix__sparse__1 = do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__sparse__1 errStrPtrP errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_sparse__1 :: 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 -> IO (Ptr IMatrix') casadi__IMatrix__sparse__2 :: Int -> IO IMatrix casadi__IMatrix__sparse__2 x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__sparse__2 errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_sparse__2 :: Int -> IO IMatrix imatrix_sparse__2 = casadi__IMatrix__sparse__2 -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__sparse__3" c_casadi__IMatrix__sparse__3 :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr IMatrix') casadi__IMatrix__sparse__3 :: Int -> Int -> IO IMatrix casadi__IMatrix__sparse__3 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__sparse__3 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_sparse__3 :: Int -> Int -> IO IMatrix imatrix_sparse__3 = casadi__IMatrix__sparse__3 -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__sparsity" c_casadi__IMatrix__sparsity :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr Sparsity') casadi__IMatrix__sparsity :: IMatrix -> IO Sparsity casadi__IMatrix__sparsity x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__sparsity errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_sparsity :: IMatrixClass a => a -> IO Sparsity imatrix_sparsity x = casadi__IMatrix__sparsity (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__sparsityRef" c_casadi__IMatrix__sparsityRef :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr Sparsity') casadi__IMatrix__sparsityRef :: IMatrix -> IO Sparsity casadi__IMatrix__sparsityRef x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__sparsityRef errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_sparsityRef :: IMatrixClass a => a -> IO Sparsity imatrix_sparsityRef x = casadi__IMatrix__sparsityRef (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__toSlice__0" c_casadi__IMatrix__toSlice__0 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr Slice') casadi__IMatrix__toSlice__0 :: IMatrix -> IO Slice casadi__IMatrix__toSlice__0 x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__toSlice__0 errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_toSlice__0 :: IMatrixClass a => a -> IO Slice imatrix_toSlice__0 x = casadi__IMatrix__toSlice__0 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__toSlice__1" c_casadi__IMatrix__toSlice__1 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> IO (Ptr Slice') casadi__IMatrix__toSlice__1 :: IMatrix -> Bool -> IO Slice casadi__IMatrix__toSlice__1 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__toSlice__1 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_toSlice__1 :: IMatrixClass a => a -> Bool -> IO Slice imatrix_toSlice__1 x = casadi__IMatrix__toSlice__1 (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 IMatrix' -> CInt -> CInt -> IO (Ptr IMatrix') casadi__IMatrix__triplet__0 :: Vector Int -> Vector Int -> IMatrix -> 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 -> IMatrix -> 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 IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__triplet__1 :: Vector Int -> Vector Int -> IMatrix -> 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 -> IMatrix -> 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 -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_abs" c_casadi__IMatrix__zz_abs :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__zz_abs :: IMatrix -> IO IMatrix casadi__IMatrix__zz_abs x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_abs errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_abs :: IMatrixClass a => a -> IO IMatrix imatrix_zz_abs x = casadi__IMatrix__zz_abs (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_acos" c_casadi__IMatrix__zz_acos :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__zz_acos :: IMatrix -> IO IMatrix casadi__IMatrix__zz_acos x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_acos errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_acos :: IMatrixClass a => a -> IO IMatrix imatrix_zz_acos x = casadi__IMatrix__zz_acos (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_acosh" c_casadi__IMatrix__zz_acosh :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__zz_acosh :: IMatrix -> IO IMatrix casadi__IMatrix__zz_acosh x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_acosh errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_acosh :: IMatrixClass a => a -> IO IMatrix imatrix_zz_acosh x = casadi__IMatrix__zz_acosh (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_adj" c_casadi__IMatrix__zz_adj :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__zz_adj :: IMatrix -> IO IMatrix casadi__IMatrix__zz_adj x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_adj errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_adj :: IMatrixClass a => a -> IO IMatrix imatrix_zz_adj x = casadi__IMatrix__zz_adj (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_all" c_casadi__IMatrix__zz_all :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__zz_all :: IMatrix -> IO IMatrix casadi__IMatrix__zz_all x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_all errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_all :: IMatrixClass a => a -> IO IMatrix imatrix_zz_all x = casadi__IMatrix__zz_all (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_and" c_casadi__IMatrix__zz_and :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__zz_and :: IMatrix -> IMatrix -> IO IMatrix casadi__IMatrix__zz_and x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_and errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_and :: IMatrixClass a => a -> IMatrix -> IO IMatrix imatrix_zz_and x = casadi__IMatrix__zz_and (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_any" c_casadi__IMatrix__zz_any :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__zz_any :: IMatrix -> IO IMatrix casadi__IMatrix__zz_any x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_any errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_any :: IMatrixClass a => a -> IO IMatrix imatrix_zz_any x = casadi__IMatrix__zz_any (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_asin" c_casadi__IMatrix__zz_asin :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__zz_asin :: IMatrix -> IO IMatrix casadi__IMatrix__zz_asin x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_asin errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_asin :: IMatrixClass a => a -> IO IMatrix imatrix_zz_asin x = casadi__IMatrix__zz_asin (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_asinh" c_casadi__IMatrix__zz_asinh :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__zz_asinh :: IMatrix -> IO IMatrix casadi__IMatrix__zz_asinh x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_asinh errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_asinh :: IMatrixClass a => a -> IO IMatrix imatrix_zz_asinh x = casadi__IMatrix__zz_asinh (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_atan" c_casadi__IMatrix__zz_atan :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__zz_atan :: IMatrix -> IO IMatrix casadi__IMatrix__zz_atan x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_atan errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_atan :: IMatrixClass a => a -> IO IMatrix imatrix_zz_atan x = casadi__IMatrix__zz_atan (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_atan2" c_casadi__IMatrix__zz_atan2 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__zz_atan2 :: IMatrix -> IMatrix -> IO IMatrix casadi__IMatrix__zz_atan2 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_atan2 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_atan2 :: IMatrixClass a => a -> IMatrix -> IO IMatrix imatrix_zz_atan2 x = casadi__IMatrix__zz_atan2 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_atanh" c_casadi__IMatrix__zz_atanh :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__zz_atanh :: IMatrix -> IO IMatrix casadi__IMatrix__zz_atanh x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_atanh errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_atanh :: IMatrixClass a => a -> IO IMatrix imatrix_zz_atanh x = casadi__IMatrix__zz_atanh (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_blockcat" c_casadi__IMatrix__zz_blockcat :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr (StdVec (Ptr IMatrix')))) -> IO (Ptr IMatrix') casadi__IMatrix__zz_blockcat :: Vector (Vector IMatrix) -> IO IMatrix casadi__IMatrix__zz_blockcat x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_blockcat errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_blockcat :: Vector (Vector IMatrix) -> IO IMatrix imatrix_zz_blockcat = casadi__IMatrix__zz_blockcat -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_blocksplit" c_casadi__IMatrix__zz_blocksplit :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr (StdVec (Ptr IMatrix'))))) casadi__IMatrix__zz_blocksplit :: IMatrix -> Vector Int -> Vector Int -> IO (Vector (Vector IMatrix)) casadi__IMatrix__zz_blocksplit x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_blocksplit errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_blocksplit :: IMatrixClass a => a -> Vector Int -> Vector Int -> IO (Vector (Vector IMatrix)) imatrix_zz_blocksplit x = casadi__IMatrix__zz_blocksplit (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_ceil" c_casadi__IMatrix__zz_ceil :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__zz_ceil :: IMatrix -> IO IMatrix casadi__IMatrix__zz_ceil x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_ceil errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_ceil :: IMatrixClass a => a -> IO IMatrix imatrix_zz_ceil x = casadi__IMatrix__zz_ceil (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_cofactor" c_casadi__IMatrix__zz_cofactor :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> CInt -> IO (Ptr IMatrix') casadi__IMatrix__zz_cofactor :: IMatrix -> Int -> Int -> IO IMatrix casadi__IMatrix__zz_cofactor x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_cofactor errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_cofactor :: IMatrixClass a => a -> Int -> Int -> IO IMatrix imatrix_zz_cofactor x = casadi__IMatrix__zz_cofactor (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_cos" c_casadi__IMatrix__zz_cos :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__zz_cos :: IMatrix -> IO IMatrix casadi__IMatrix__zz_cos x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_cos errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_cos :: IMatrixClass a => a -> IO IMatrix imatrix_zz_cos x = casadi__IMatrix__zz_cos (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_cosh" c_casadi__IMatrix__zz_cosh :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__zz_cosh :: IMatrix -> IO IMatrix casadi__IMatrix__zz_cosh x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_cosh errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_cosh :: IMatrixClass a => a -> IO IMatrix imatrix_zz_cosh x = casadi__IMatrix__zz_cosh (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_countNodes" c_casadi__IMatrix__zz_countNodes :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt casadi__IMatrix__zz_countNodes :: IMatrix -> IO Int casadi__IMatrix__zz_countNodes x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_countNodes errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_countNodes :: IMatrixClass a => a -> IO Int imatrix_zz_countNodes x = casadi__IMatrix__zz_countNodes (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_cross__0" c_casadi__IMatrix__zz_cross__0 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__zz_cross__0 :: IMatrix -> IMatrix -> IO IMatrix casadi__IMatrix__zz_cross__0 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_cross__0 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_cross__0 :: IMatrixClass a => a -> IMatrix -> IO IMatrix imatrix_zz_cross__0 x = casadi__IMatrix__zz_cross__0 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_cross__1" c_casadi__IMatrix__zz_cross__1 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> IO (Ptr IMatrix') casadi__IMatrix__zz_cross__1 :: IMatrix -> IMatrix -> Int -> IO IMatrix casadi__IMatrix__zz_cross__1 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_cross__1 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_cross__1 :: IMatrixClass a => a -> IMatrix -> Int -> IO IMatrix imatrix_zz_cross__1 x = casadi__IMatrix__zz_cross__1 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_densify" c_casadi__IMatrix__zz_densify :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__zz_densify :: IMatrix -> IO IMatrix casadi__IMatrix__zz_densify x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_densify errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_densify :: IMatrixClass a => a -> IO IMatrix imatrix_zz_densify x = casadi__IMatrix__zz_densify (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_dependsOn" c_casadi__IMatrix__zz_dependsOn :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO CInt casadi__IMatrix__zz_dependsOn :: IMatrix -> IMatrix -> IO Bool casadi__IMatrix__zz_dependsOn x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_dependsOn errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_dependsOn :: IMatrixClass a => a -> IMatrix -> IO Bool imatrix_zz_dependsOn x = casadi__IMatrix__zz_dependsOn (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_det" c_casadi__IMatrix__zz_det :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__zz_det :: IMatrix -> IO IMatrix casadi__IMatrix__zz_det x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_det errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_det :: IMatrixClass a => a -> IO IMatrix imatrix_zz_det x = casadi__IMatrix__zz_det (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_diag" c_casadi__IMatrix__zz_diag :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__zz_diag :: IMatrix -> IO IMatrix casadi__IMatrix__zz_diag x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_diag errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_diag :: IMatrixClass a => a -> IO IMatrix imatrix_zz_diag x = casadi__IMatrix__zz_diag (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_diagcat" c_casadi__IMatrix__zz_diagcat :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr IMatrix')) -> IO (Ptr IMatrix') casadi__IMatrix__zz_diagcat :: Vector IMatrix -> IO IMatrix casadi__IMatrix__zz_diagcat x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_diagcat errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_diagcat :: Vector IMatrix -> IO IMatrix imatrix_zz_diagcat = casadi__IMatrix__zz_diagcat -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_diagsplit" c_casadi__IMatrix__zz_diagsplit :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr IMatrix'))) casadi__IMatrix__zz_diagsplit :: IMatrix -> Vector Int -> Vector Int -> IO (Vector IMatrix) casadi__IMatrix__zz_diagsplit x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_diagsplit errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_diagsplit :: IMatrixClass a => a -> Vector Int -> Vector Int -> IO (Vector IMatrix) imatrix_zz_diagsplit x = casadi__IMatrix__zz_diagsplit (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_eig_symbolic" c_casadi__IMatrix__zz_eig_symbolic :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__zz_eig_symbolic :: IMatrix -> IO IMatrix casadi__IMatrix__zz_eig_symbolic x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_eig_symbolic errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_eig_symbolic :: IMatrixClass a => a -> IO IMatrix imatrix_zz_eig_symbolic x = casadi__IMatrix__zz_eig_symbolic (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_eq" c_casadi__IMatrix__zz_eq :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__zz_eq :: IMatrix -> IMatrix -> IO IMatrix casadi__IMatrix__zz_eq x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_eq errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_eq :: IMatrixClass a => a -> IMatrix -> IO IMatrix imatrix_zz_eq x = casadi__IMatrix__zz_eq (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_erf" c_casadi__IMatrix__zz_erf :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__zz_erf :: IMatrix -> IO IMatrix casadi__IMatrix__zz_erf x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_erf errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_erf :: IMatrixClass a => a -> IO IMatrix imatrix_zz_erf x = casadi__IMatrix__zz_erf (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_erfinv" c_casadi__IMatrix__zz_erfinv :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__zz_erfinv :: IMatrix -> IO IMatrix casadi__IMatrix__zz_erfinv x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_erfinv errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_erfinv :: IMatrixClass a => a -> IO IMatrix imatrix_zz_erfinv x = casadi__IMatrix__zz_erfinv (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_exp" c_casadi__IMatrix__zz_exp :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__zz_exp :: IMatrix -> IO IMatrix casadi__IMatrix__zz_exp x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_exp errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_exp :: IMatrixClass a => a -> IO IMatrix imatrix_zz_exp x = casadi__IMatrix__zz_exp (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_expand" c_casadi__IMatrix__zz_expand :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> IO () casadi__IMatrix__zz_expand :: IMatrix -> IMatrix -> IMatrix -> IO () casadi__IMatrix__zz_expand x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_expand errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_expand :: IMatrixClass a => a -> IMatrix -> IMatrix -> IO () imatrix_zz_expand x = casadi__IMatrix__zz_expand (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_extractShared__0" c_casadi__IMatrix__zz_extractShared__0 :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr IMatrix')) -> Ptr (StdVec (Ptr IMatrix')) -> Ptr (StdVec (Ptr IMatrix')) -> IO () casadi__IMatrix__zz_extractShared__0 :: Vector IMatrix -> Vector IMatrix -> Vector IMatrix -> IO () casadi__IMatrix__zz_extractShared__0 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_extractShared__0 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_extractShared__0 :: Vector IMatrix -> Vector IMatrix -> Vector IMatrix -> IO () imatrix_zz_extractShared__0 = casadi__IMatrix__zz_extractShared__0 -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_extractShared__1" c_casadi__IMatrix__zz_extractShared__1 :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr IMatrix')) -> Ptr (StdVec (Ptr IMatrix')) -> Ptr (StdVec (Ptr IMatrix')) -> Ptr StdString -> IO () casadi__IMatrix__zz_extractShared__1 :: Vector IMatrix -> Vector IMatrix -> Vector IMatrix -> String -> IO () casadi__IMatrix__zz_extractShared__1 x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_extractShared__1 errStrPtrP x0' x1' x2' x3' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_extractShared__1 :: Vector IMatrix -> Vector IMatrix -> Vector IMatrix -> String -> IO () imatrix_zz_extractShared__1 = casadi__IMatrix__zz_extractShared__1 -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_extractShared__2" c_casadi__IMatrix__zz_extractShared__2 :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr IMatrix')) -> Ptr (StdVec (Ptr IMatrix')) -> Ptr (StdVec (Ptr IMatrix')) -> Ptr StdString -> Ptr StdString -> IO () casadi__IMatrix__zz_extractShared__2 :: Vector IMatrix -> Vector IMatrix -> Vector IMatrix -> String -> String -> IO () casadi__IMatrix__zz_extractShared__2 x0 x1 x2 x3 x4 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> withMarshal x4 $ \x4' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_extractShared__2 errStrPtrP x0' x1' x2' x3' x4' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_extractShared__2 :: Vector IMatrix -> Vector IMatrix -> Vector IMatrix -> String -> String -> IO () imatrix_zz_extractShared__2 = casadi__IMatrix__zz_extractShared__2 -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_floor" c_casadi__IMatrix__zz_floor :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__zz_floor :: IMatrix -> IO IMatrix casadi__IMatrix__zz_floor x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_floor errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_floor :: IMatrixClass a => a -> IO IMatrix imatrix_zz_floor x = casadi__IMatrix__zz_floor (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_gauss_quadrature__0" c_casadi__IMatrix__zz_gauss_quadrature__0 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__zz_gauss_quadrature__0 :: IMatrix -> IMatrix -> IMatrix -> IMatrix -> Int -> IMatrix -> IO IMatrix casadi__IMatrix__zz_gauss_quadrature__0 x0 x1 x2 x3 x4 x5 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> withMarshal x4 $ \x4' -> withMarshal x5 $ \x5' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_gauss_quadrature__0 errStrPtrP x0' x1' x2' x3' x4' x5' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_gauss_quadrature__0 :: IMatrixClass a => a -> IMatrix -> IMatrix -> IMatrix -> Int -> IMatrix -> IO IMatrix imatrix_zz_gauss_quadrature__0 x = casadi__IMatrix__zz_gauss_quadrature__0 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_gauss_quadrature__1" c_casadi__IMatrix__zz_gauss_quadrature__1 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__zz_gauss_quadrature__1 :: IMatrix -> IMatrix -> IMatrix -> IMatrix -> IO IMatrix casadi__IMatrix__zz_gauss_quadrature__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__zz_gauss_quadrature__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_zz_gauss_quadrature__1 :: IMatrixClass a => a -> IMatrix -> IMatrix -> IMatrix -> IO IMatrix imatrix_zz_gauss_quadrature__1 x = casadi__IMatrix__zz_gauss_quadrature__1 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_gauss_quadrature__2" c_casadi__IMatrix__zz_gauss_quadrature__2 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> IO (Ptr IMatrix') casadi__IMatrix__zz_gauss_quadrature__2 :: IMatrix -> IMatrix -> IMatrix -> IMatrix -> Int -> IO IMatrix casadi__IMatrix__zz_gauss_quadrature__2 x0 x1 x2 x3 x4 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> withMarshal x4 $ \x4' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_gauss_quadrature__2 errStrPtrP x0' x1' x2' x3' x4' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_gauss_quadrature__2 :: IMatrixClass a => a -> IMatrix -> IMatrix -> IMatrix -> Int -> IO IMatrix imatrix_zz_gauss_quadrature__2 x = casadi__IMatrix__zz_gauss_quadrature__2 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_ge" c_casadi__IMatrix__zz_ge :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__zz_ge :: IMatrix -> IMatrix -> IO IMatrix casadi__IMatrix__zz_ge x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_ge errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_ge :: IMatrixClass a => a -> IMatrix -> IO IMatrix imatrix_zz_ge x = casadi__IMatrix__zz_ge (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_getMinor" c_casadi__IMatrix__zz_getMinor :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> CInt -> IO (Ptr IMatrix') casadi__IMatrix__zz_getMinor :: IMatrix -> Int -> Int -> IO IMatrix casadi__IMatrix__zz_getMinor x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_getMinor errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_getMinor :: IMatrixClass a => a -> Int -> Int -> IO IMatrix imatrix_zz_getMinor x = casadi__IMatrix__zz_getMinor (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_getOperatorRepresentation" c_casadi__IMatrix__zz_getOperatorRepresentation :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec (Ptr StdString)) -> IO (Ptr StdString) casadi__IMatrix__zz_getOperatorRepresentation :: IMatrix -> Vector String -> IO String casadi__IMatrix__zz_getOperatorRepresentation x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_getOperatorRepresentation errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_getOperatorRepresentation :: IMatrixClass a => a -> Vector String -> IO String imatrix_zz_getOperatorRepresentation x = casadi__IMatrix__zz_getOperatorRepresentation (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_getSymbols__0" c_casadi__IMatrix__zz_getSymbols__0 :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr IMatrix')) -> IO (Ptr (StdVec (Ptr IMatrix'))) casadi__IMatrix__zz_getSymbols__0 :: Vector IMatrix -> IO (Vector IMatrix) casadi__IMatrix__zz_getSymbols__0 x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_getSymbols__0 errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_getSymbols__0 :: Vector IMatrix -> IO (Vector IMatrix) imatrix_zz_getSymbols__0 = casadi__IMatrix__zz_getSymbols__0 -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_getSymbols__1" c_casadi__IMatrix__zz_getSymbols__1 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr (StdVec (Ptr IMatrix'))) casadi__IMatrix__zz_getSymbols__1 :: IMatrix -> IO (Vector IMatrix) casadi__IMatrix__zz_getSymbols__1 x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_getSymbols__1 errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_getSymbols__1 :: IMatrixClass a => a -> IO (Vector IMatrix) imatrix_zz_getSymbols__1 x = casadi__IMatrix__zz_getSymbols__1 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_gradient" c_casadi__IMatrix__zz_gradient :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__zz_gradient :: IMatrix -> IMatrix -> IO IMatrix casadi__IMatrix__zz_gradient x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_gradient errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_gradient :: IMatrixClass a => a -> IMatrix -> IO IMatrix imatrix_zz_gradient x = casadi__IMatrix__zz_gradient (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_gt" c_casadi__IMatrix__zz_gt :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__zz_gt :: IMatrix -> IMatrix -> IO IMatrix casadi__IMatrix__zz_gt x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_gt errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_gt :: IMatrixClass a => a -> IMatrix -> IO IMatrix imatrix_zz_gt x = casadi__IMatrix__zz_gt (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_heaviside" c_casadi__IMatrix__zz_heaviside :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__zz_heaviside :: IMatrix -> IO IMatrix casadi__IMatrix__zz_heaviside x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_heaviside errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_heaviside :: IMatrixClass a => a -> IO IMatrix imatrix_zz_heaviside x = casadi__IMatrix__zz_heaviside (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_hessian__0" c_casadi__IMatrix__zz_hessian__0 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> IO () casadi__IMatrix__zz_hessian__0 :: IMatrix -> IMatrix -> IMatrix -> IMatrix -> IO () casadi__IMatrix__zz_hessian__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__zz_hessian__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_zz_hessian__0 :: IMatrixClass a => a -> IMatrix -> IMatrix -> IMatrix -> IO () imatrix_zz_hessian__0 x = casadi__IMatrix__zz_hessian__0 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_hessian__1" c_casadi__IMatrix__zz_hessian__1 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__zz_hessian__1 :: IMatrix -> IMatrix -> IO IMatrix casadi__IMatrix__zz_hessian__1 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_hessian__1 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_hessian__1 :: IMatrixClass a => a -> IMatrix -> IO IMatrix imatrix_zz_hessian__1 x = casadi__IMatrix__zz_hessian__1 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_horzcat" c_casadi__IMatrix__zz_horzcat :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr IMatrix')) -> IO (Ptr IMatrix') casadi__IMatrix__zz_horzcat :: Vector IMatrix -> IO IMatrix casadi__IMatrix__zz_horzcat x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_horzcat errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_horzcat :: Vector IMatrix -> IO IMatrix imatrix_zz_horzcat = casadi__IMatrix__zz_horzcat -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_horzsplit" c_casadi__IMatrix__zz_horzsplit :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr IMatrix'))) casadi__IMatrix__zz_horzsplit :: IMatrix -> Vector Int -> IO (Vector IMatrix) casadi__IMatrix__zz_horzsplit x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_horzsplit errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_horzsplit :: IMatrixClass a => a -> Vector Int -> IO (Vector IMatrix) imatrix_zz_horzsplit x = casadi__IMatrix__zz_horzsplit (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_if_else" c_casadi__IMatrix__zz_if_else :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__zz_if_else :: IMatrix -> IMatrix -> IMatrix -> IO IMatrix casadi__IMatrix__zz_if_else x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_if_else errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_if_else :: IMatrixClass a => a -> IMatrix -> IMatrix -> IO IMatrix imatrix_zz_if_else x = casadi__IMatrix__zz_if_else (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_if_else_zero" c_casadi__IMatrix__zz_if_else_zero :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__zz_if_else_zero :: IMatrix -> IMatrix -> IO IMatrix casadi__IMatrix__zz_if_else_zero x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_if_else_zero errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_if_else_zero :: IMatrixClass a => a -> IMatrix -> IO IMatrix imatrix_zz_if_else_zero x = casadi__IMatrix__zz_if_else_zero (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_inner_prod" c_casadi__IMatrix__zz_inner_prod :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__zz_inner_prod :: IMatrix -> IMatrix -> IO IMatrix casadi__IMatrix__zz_inner_prod x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_inner_prod errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_inner_prod :: IMatrixClass a => a -> IMatrix -> IO IMatrix imatrix_zz_inner_prod x = casadi__IMatrix__zz_inner_prod (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_inv" c_casadi__IMatrix__zz_inv :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__zz_inv :: IMatrix -> IO IMatrix casadi__IMatrix__zz_inv x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_inv errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_inv :: IMatrixClass a => a -> IO IMatrix imatrix_zz_inv x = casadi__IMatrix__zz_inv (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_isEqual__0" c_casadi__IMatrix__zz_isEqual__0 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO CInt casadi__IMatrix__zz_isEqual__0 :: IMatrix -> IMatrix -> IO Bool casadi__IMatrix__zz_isEqual__0 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_isEqual__0 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_isEqual__0 :: IMatrixClass a => a -> IMatrix -> IO Bool imatrix_zz_isEqual__0 x = casadi__IMatrix__zz_isEqual__0 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_isEqual__1" c_casadi__IMatrix__zz_isEqual__1 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> IO CInt casadi__IMatrix__zz_isEqual__1 :: IMatrix -> IMatrix -> Int -> IO Bool casadi__IMatrix__zz_isEqual__1 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_isEqual__1 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_isEqual__1 :: IMatrixClass a => a -> IMatrix -> Int -> IO Bool imatrix_zz_isEqual__1 x = casadi__IMatrix__zz_isEqual__1 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_jacobian" c_casadi__IMatrix__zz_jacobian :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__zz_jacobian :: IMatrix -> IMatrix -> IO IMatrix casadi__IMatrix__zz_jacobian x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_jacobian errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_jacobian :: IMatrixClass a => a -> IMatrix -> IO IMatrix imatrix_zz_jacobian x = casadi__IMatrix__zz_jacobian (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_jacobianTimesVector__0" c_casadi__IMatrix__zz_jacobianTimesVector__0 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__zz_jacobianTimesVector__0 :: IMatrix -> IMatrix -> IMatrix -> IO IMatrix casadi__IMatrix__zz_jacobianTimesVector__0 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_jacobianTimesVector__0 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_jacobianTimesVector__0 :: IMatrixClass a => a -> IMatrix -> IMatrix -> IO IMatrix imatrix_zz_jacobianTimesVector__0 x = casadi__IMatrix__zz_jacobianTimesVector__0 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_jacobianTimesVector__1" c_casadi__IMatrix__zz_jacobianTimesVector__1 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> IO (Ptr IMatrix') casadi__IMatrix__zz_jacobianTimesVector__1 :: IMatrix -> IMatrix -> IMatrix -> Bool -> IO IMatrix casadi__IMatrix__zz_jacobianTimesVector__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__zz_jacobianTimesVector__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_zz_jacobianTimesVector__1 :: IMatrixClass a => a -> IMatrix -> IMatrix -> Bool -> IO IMatrix imatrix_zz_jacobianTimesVector__1 x = casadi__IMatrix__zz_jacobianTimesVector__1 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_kron" c_casadi__IMatrix__zz_kron :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__zz_kron :: IMatrix -> IMatrix -> IO IMatrix casadi__IMatrix__zz_kron x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_kron errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_kron :: IMatrixClass a => a -> IMatrix -> IO IMatrix imatrix_zz_kron x = casadi__IMatrix__zz_kron (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_le" c_casadi__IMatrix__zz_le :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__zz_le :: IMatrix -> IMatrix -> IO IMatrix casadi__IMatrix__zz_le x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_le errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_le :: IMatrixClass a => a -> IMatrix -> IO IMatrix imatrix_zz_le x = casadi__IMatrix__zz_le (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_linspace" c_casadi__IMatrix__zz_linspace :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> IO (Ptr IMatrix') casadi__IMatrix__zz_linspace :: IMatrix -> IMatrix -> Int -> IO IMatrix casadi__IMatrix__zz_linspace x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_linspace errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_linspace :: IMatrixClass a => a -> IMatrix -> Int -> IO IMatrix imatrix_zz_linspace x = casadi__IMatrix__zz_linspace (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_log" c_casadi__IMatrix__zz_log :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__zz_log :: IMatrix -> IO IMatrix casadi__IMatrix__zz_log x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_log errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_log :: IMatrixClass a => a -> IO IMatrix imatrix_zz_log x = casadi__IMatrix__zz_log (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_log10" c_casadi__IMatrix__zz_log10 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__zz_log10 :: IMatrix -> IO IMatrix casadi__IMatrix__zz_log10 x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_log10 errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_log10 :: IMatrixClass a => a -> IO IMatrix imatrix_zz_log10 x = casadi__IMatrix__zz_log10 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_lt" c_casadi__IMatrix__zz_lt :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__zz_lt :: IMatrix -> IMatrix -> IO IMatrix casadi__IMatrix__zz_lt x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_lt errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_lt :: IMatrixClass a => a -> IMatrix -> IO IMatrix imatrix_zz_lt x = casadi__IMatrix__zz_lt (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_max" c_casadi__IMatrix__zz_max :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__zz_max :: IMatrix -> IMatrix -> IO IMatrix casadi__IMatrix__zz_max x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_max errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_max :: IMatrixClass a => a -> IMatrix -> IO IMatrix imatrix_zz_max x = casadi__IMatrix__zz_max (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_min" c_casadi__IMatrix__zz_min :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__zz_min :: IMatrix -> IMatrix -> IO IMatrix casadi__IMatrix__zz_min x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_min errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_min :: IMatrixClass a => a -> IMatrix -> IO IMatrix imatrix_zz_min x = casadi__IMatrix__zz_min (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_minus" c_casadi__IMatrix__zz_minus :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__zz_minus :: IMatrix -> IMatrix -> IO IMatrix casadi__IMatrix__zz_minus x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_minus errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_minus :: IMatrixClass a => a -> IMatrix -> IO IMatrix imatrix_zz_minus x = casadi__IMatrix__zz_minus (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_mod" c_casadi__IMatrix__zz_mod :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__zz_mod :: IMatrix -> IMatrix -> IO IMatrix casadi__IMatrix__zz_mod x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_mod errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_mod :: IMatrixClass a => a -> IMatrix -> IO IMatrix imatrix_zz_mod x = casadi__IMatrix__zz_mod (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_mpower" c_casadi__IMatrix__zz_mpower :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__zz_mpower :: IMatrix -> IMatrix -> IO IMatrix casadi__IMatrix__zz_mpower x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_mpower errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_mpower :: IMatrixClass a => a -> IMatrix -> IO IMatrix imatrix_zz_mpower x = casadi__IMatrix__zz_mpower (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_mtaylor__0" c_casadi__IMatrix__zz_mtaylor__0 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> Ptr (StdVec CInt) -> IO (Ptr IMatrix') casadi__IMatrix__zz_mtaylor__0 :: IMatrix -> IMatrix -> IMatrix -> Int -> Vector Int -> IO IMatrix casadi__IMatrix__zz_mtaylor__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__zz_mtaylor__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_zz_mtaylor__0 :: IMatrixClass a => a -> IMatrix -> IMatrix -> Int -> Vector Int -> IO IMatrix imatrix_zz_mtaylor__0 x = casadi__IMatrix__zz_mtaylor__0 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_mtaylor__1" c_casadi__IMatrix__zz_mtaylor__1 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__zz_mtaylor__1 :: IMatrix -> IMatrix -> IMatrix -> IO IMatrix casadi__IMatrix__zz_mtaylor__1 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_mtaylor__1 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_mtaylor__1 :: IMatrixClass a => a -> IMatrix -> IMatrix -> IO IMatrix imatrix_zz_mtaylor__1 x = casadi__IMatrix__zz_mtaylor__1 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_mtaylor__2" c_casadi__IMatrix__zz_mtaylor__2 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> IO (Ptr IMatrix') casadi__IMatrix__zz_mtaylor__2 :: IMatrix -> IMatrix -> IMatrix -> Int -> IO IMatrix casadi__IMatrix__zz_mtaylor__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__zz_mtaylor__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_zz_mtaylor__2 :: IMatrixClass a => a -> IMatrix -> IMatrix -> Int -> IO IMatrix imatrix_zz_mtaylor__2 x = casadi__IMatrix__zz_mtaylor__2 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_mtimes__0" c_casadi__IMatrix__zz_mtimes__0 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__zz_mtimes__0 :: IMatrix -> IMatrix -> IMatrix -> IO IMatrix casadi__IMatrix__zz_mtimes__0 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_mtimes__0 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_mtimes__0 :: IMatrixClass a => a -> IMatrix -> IMatrix -> IO IMatrix imatrix_zz_mtimes__0 x = casadi__IMatrix__zz_mtimes__0 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_mtimes__1" c_casadi__IMatrix__zz_mtimes__1 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__zz_mtimes__1 :: IMatrix -> IMatrix -> IO IMatrix casadi__IMatrix__zz_mtimes__1 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_mtimes__1 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_mtimes__1 :: IMatrixClass a => a -> IMatrix -> IO IMatrix imatrix_zz_mtimes__1 x = casadi__IMatrix__zz_mtimes__1 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_ne" c_casadi__IMatrix__zz_ne :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__zz_ne :: IMatrix -> IMatrix -> IO IMatrix casadi__IMatrix__zz_ne x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_ne errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_ne :: IMatrixClass a => a -> IMatrix -> IO IMatrix imatrix_zz_ne x = casadi__IMatrix__zz_ne (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_norm_0_mul" c_casadi__IMatrix__zz_norm_0_mul :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO CInt casadi__IMatrix__zz_norm_0_mul :: IMatrix -> IMatrix -> IO Int casadi__IMatrix__zz_norm_0_mul x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_norm_0_mul errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_norm_0_mul :: IMatrixClass a => a -> IMatrix -> IO Int imatrix_zz_norm_0_mul x = casadi__IMatrix__zz_norm_0_mul (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_norm_1" c_casadi__IMatrix__zz_norm_1 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__zz_norm_1 :: IMatrix -> IO IMatrix casadi__IMatrix__zz_norm_1 x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_norm_1 errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_norm_1 :: IMatrixClass a => a -> IO IMatrix imatrix_zz_norm_1 x = casadi__IMatrix__zz_norm_1 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_norm_2" c_casadi__IMatrix__zz_norm_2 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__zz_norm_2 :: IMatrix -> IO IMatrix casadi__IMatrix__zz_norm_2 x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_norm_2 errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_norm_2 :: IMatrixClass a => a -> IO IMatrix imatrix_zz_norm_2 x = casadi__IMatrix__zz_norm_2 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_norm_F" c_casadi__IMatrix__zz_norm_F :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__zz_norm_F :: IMatrix -> IO IMatrix casadi__IMatrix__zz_norm_F x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_norm_F errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_norm_F :: IMatrixClass a => a -> IO IMatrix imatrix_zz_norm_F x = casadi__IMatrix__zz_norm_F (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_norm_inf" c_casadi__IMatrix__zz_norm_inf :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__zz_norm_inf :: IMatrix -> IO IMatrix casadi__IMatrix__zz_norm_inf x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_norm_inf errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_norm_inf :: IMatrixClass a => a -> IO IMatrix imatrix_zz_norm_inf x = casadi__IMatrix__zz_norm_inf (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_norm_inf_mul" c_casadi__IMatrix__zz_norm_inf_mul :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__zz_norm_inf_mul :: IMatrix -> IMatrix -> IO IMatrix casadi__IMatrix__zz_norm_inf_mul x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_norm_inf_mul errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_norm_inf_mul :: IMatrixClass a => a -> IMatrix -> IO IMatrix imatrix_zz_norm_inf_mul x = casadi__IMatrix__zz_norm_inf_mul (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_not" c_casadi__IMatrix__zz_not :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__zz_not :: IMatrix -> IO IMatrix casadi__IMatrix__zz_not x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_not errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_not :: IMatrixClass a => a -> IO IMatrix imatrix_zz_not x = casadi__IMatrix__zz_not (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_nullspace" c_casadi__IMatrix__zz_nullspace :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__zz_nullspace :: IMatrix -> IO IMatrix casadi__IMatrix__zz_nullspace x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_nullspace errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_nullspace :: IMatrixClass a => a -> IO IMatrix imatrix_zz_nullspace x = casadi__IMatrix__zz_nullspace (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_or" c_casadi__IMatrix__zz_or :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__zz_or :: IMatrix -> IMatrix -> IO IMatrix casadi__IMatrix__zz_or x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_or errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_or :: IMatrixClass a => a -> IMatrix -> IO IMatrix imatrix_zz_or x = casadi__IMatrix__zz_or (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_outer_prod" c_casadi__IMatrix__zz_outer_prod :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__zz_outer_prod :: IMatrix -> IMatrix -> IO IMatrix casadi__IMatrix__zz_outer_prod x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_outer_prod errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_outer_prod :: IMatrixClass a => a -> IMatrix -> IO IMatrix imatrix_zz_outer_prod x = casadi__IMatrix__zz_outer_prod (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_pinv" c_casadi__IMatrix__zz_pinv :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__zz_pinv :: IMatrix -> IO IMatrix casadi__IMatrix__zz_pinv x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_pinv errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_pinv :: IMatrixClass a => a -> IO IMatrix imatrix_zz_pinv x = casadi__IMatrix__zz_pinv (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_plus" c_casadi__IMatrix__zz_plus :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__zz_plus :: IMatrix -> IMatrix -> IO IMatrix casadi__IMatrix__zz_plus x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_plus errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_plus :: IMatrixClass a => a -> IMatrix -> IO IMatrix imatrix_zz_plus x = casadi__IMatrix__zz_plus (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_poly_coeff" c_casadi__IMatrix__zz_poly_coeff :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__zz_poly_coeff :: IMatrix -> IMatrix -> IO IMatrix casadi__IMatrix__zz_poly_coeff x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_poly_coeff errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_poly_coeff :: IMatrixClass a => a -> IMatrix -> IO IMatrix imatrix_zz_poly_coeff x = casadi__IMatrix__zz_poly_coeff (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_poly_roots" c_casadi__IMatrix__zz_poly_roots :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__zz_poly_roots :: IMatrix -> IO IMatrix casadi__IMatrix__zz_poly_roots x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_poly_roots errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_poly_roots :: IMatrixClass a => a -> IO IMatrix imatrix_zz_poly_roots x = casadi__IMatrix__zz_poly_roots (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_polyval" c_casadi__IMatrix__zz_polyval :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__zz_polyval :: IMatrix -> IMatrix -> IO IMatrix casadi__IMatrix__zz_polyval x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_polyval errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_polyval :: IMatrixClass a => a -> IMatrix -> IO IMatrix imatrix_zz_polyval x = casadi__IMatrix__zz_polyval (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_power" c_casadi__IMatrix__zz_power :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__zz_power :: IMatrix -> IMatrix -> IO IMatrix casadi__IMatrix__zz_power x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_power errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_power :: IMatrixClass a => a -> IMatrix -> IO IMatrix imatrix_zz_power x = casadi__IMatrix__zz_power (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_printCompact" c_casadi__IMatrix__zz_printCompact :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO () casadi__IMatrix__zz_printCompact :: IMatrix -> IO () casadi__IMatrix__zz_printCompact x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_printCompact errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_printCompact :: IMatrixClass a => a -> IO () imatrix_zz_printCompact x = casadi__IMatrix__zz_printCompact (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_project" c_casadi__IMatrix__zz_project :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr Sparsity' -> IO (Ptr IMatrix') casadi__IMatrix__zz_project :: IMatrix -> Sparsity -> IO IMatrix casadi__IMatrix__zz_project x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_project errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_project :: IMatrixClass a => a -> Sparsity -> IO IMatrix imatrix_zz_project x = casadi__IMatrix__zz_project (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_pw_const" c_casadi__IMatrix__zz_pw_const :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__zz_pw_const :: IMatrix -> IMatrix -> IMatrix -> IO IMatrix casadi__IMatrix__zz_pw_const x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_pw_const errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_pw_const :: IMatrixClass a => a -> IMatrix -> IMatrix -> IO IMatrix imatrix_zz_pw_const x = casadi__IMatrix__zz_pw_const (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_pw_lin" c_casadi__IMatrix__zz_pw_lin :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__zz_pw_lin :: IMatrix -> IMatrix -> IMatrix -> IO IMatrix casadi__IMatrix__zz_pw_lin x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_pw_lin errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_pw_lin :: IMatrixClass a => a -> IMatrix -> IMatrix -> IO IMatrix imatrix_zz_pw_lin x = casadi__IMatrix__zz_pw_lin (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_qr" c_casadi__IMatrix__zz_qr :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> IO () casadi__IMatrix__zz_qr :: IMatrix -> IMatrix -> IMatrix -> IO () casadi__IMatrix__zz_qr x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_qr errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_qr :: IMatrixClass a => a -> IMatrix -> IMatrix -> IO () imatrix_zz_qr x = casadi__IMatrix__zz_qr (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_quad_form__0" c_casadi__IMatrix__zz_quad_form__0 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__zz_quad_form__0 :: IMatrix -> IMatrix -> IO IMatrix casadi__IMatrix__zz_quad_form__0 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_quad_form__0 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_quad_form__0 :: IMatrixClass a => a -> IMatrix -> IO IMatrix imatrix_zz_quad_form__0 x = casadi__IMatrix__zz_quad_form__0 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_quad_form__1" c_casadi__IMatrix__zz_quad_form__1 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__zz_quad_form__1 :: IMatrix -> IO IMatrix casadi__IMatrix__zz_quad_form__1 x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_quad_form__1 errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_quad_form__1 :: IMatrixClass a => a -> IO IMatrix imatrix_zz_quad_form__1 x = casadi__IMatrix__zz_quad_form__1 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_quad_form__2" c_casadi__IMatrix__zz_quad_form__2 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__zz_quad_form__2 :: IMatrix -> IO IMatrix casadi__IMatrix__zz_quad_form__2 x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_quad_form__2 errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_quad_form__2 :: IMatrixClass a => a -> IO IMatrix imatrix_zz_quad_form__2 x = casadi__IMatrix__zz_quad_form__2 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_quad_form__3" c_casadi__IMatrix__zz_quad_form__3 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__zz_quad_form__3 :: IMatrix -> IMatrix -> IO IMatrix casadi__IMatrix__zz_quad_form__3 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_quad_form__3 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_quad_form__3 :: IMatrixClass a => a -> IMatrix -> IO IMatrix imatrix_zz_quad_form__3 x = casadi__IMatrix__zz_quad_form__3 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_ramp" c_casadi__IMatrix__zz_ramp :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__zz_ramp :: IMatrix -> IO IMatrix casadi__IMatrix__zz_ramp x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_ramp errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_ramp :: IMatrixClass a => a -> IO IMatrix imatrix_zz_ramp x = casadi__IMatrix__zz_ramp (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_rdivide" c_casadi__IMatrix__zz_rdivide :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__zz_rdivide :: IMatrix -> IMatrix -> IO IMatrix casadi__IMatrix__zz_rdivide x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_rdivide errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_rdivide :: IMatrixClass a => a -> IMatrix -> IO IMatrix imatrix_zz_rdivide x = casadi__IMatrix__zz_rdivide (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_rectangle" c_casadi__IMatrix__zz_rectangle :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__zz_rectangle :: IMatrix -> IO IMatrix casadi__IMatrix__zz_rectangle x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_rectangle errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_rectangle :: IMatrixClass a => a -> IO IMatrix imatrix_zz_rectangle x = casadi__IMatrix__zz_rectangle (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_repmat__0" c_casadi__IMatrix__zz_repmat__0 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> IO (Ptr IMatrix') casadi__IMatrix__zz_repmat__0 :: IMatrix -> Int -> IO IMatrix casadi__IMatrix__zz_repmat__0 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_repmat__0 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_repmat__0 :: IMatrixClass a => a -> Int -> IO IMatrix imatrix_zz_repmat__0 x = casadi__IMatrix__zz_repmat__0 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_repmat__1" c_casadi__IMatrix__zz_repmat__1 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> CInt -> IO (Ptr IMatrix') casadi__IMatrix__zz_repmat__1 :: IMatrix -> Int -> Int -> IO IMatrix casadi__IMatrix__zz_repmat__1 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_repmat__1 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_repmat__1 :: IMatrixClass a => a -> Int -> Int -> IO IMatrix imatrix_zz_repmat__1 x = casadi__IMatrix__zz_repmat__1 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_reshape__0" c_casadi__IMatrix__zz_reshape__0 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr Sparsity' -> IO (Ptr IMatrix') casadi__IMatrix__zz_reshape__0 :: IMatrix -> Sparsity -> IO IMatrix casadi__IMatrix__zz_reshape__0 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_reshape__0 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_reshape__0 :: IMatrixClass a => a -> Sparsity -> IO IMatrix imatrix_zz_reshape__0 x = casadi__IMatrix__zz_reshape__0 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_reshape__1" c_casadi__IMatrix__zz_reshape__1 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> CInt -> IO (Ptr IMatrix') casadi__IMatrix__zz_reshape__1 :: IMatrix -> Int -> Int -> IO IMatrix casadi__IMatrix__zz_reshape__1 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_reshape__1 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_reshape__1 :: IMatrixClass a => a -> Int -> Int -> IO IMatrix imatrix_zz_reshape__1 x = casadi__IMatrix__zz_reshape__1 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_sign" c_casadi__IMatrix__zz_sign :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__zz_sign :: IMatrix -> IO IMatrix casadi__IMatrix__zz_sign x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_sign errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_sign :: IMatrixClass a => a -> IO IMatrix imatrix_zz_sign x = casadi__IMatrix__zz_sign (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_simplify" c_casadi__IMatrix__zz_simplify :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__zz_simplify :: IMatrix -> IO IMatrix casadi__IMatrix__zz_simplify x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_simplify errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_simplify :: IMatrixClass a => a -> IO IMatrix imatrix_zz_simplify x = casadi__IMatrix__zz_simplify (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_sin" c_casadi__IMatrix__zz_sin :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__zz_sin :: IMatrix -> IO IMatrix casadi__IMatrix__zz_sin x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_sin errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_sin :: IMatrixClass a => a -> IO IMatrix imatrix_zz_sin x = casadi__IMatrix__zz_sin (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_sinh" c_casadi__IMatrix__zz_sinh :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__zz_sinh :: IMatrix -> IO IMatrix casadi__IMatrix__zz_sinh x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_sinh errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_sinh :: IMatrixClass a => a -> IO IMatrix imatrix_zz_sinh x = casadi__IMatrix__zz_sinh (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_solve" c_casadi__IMatrix__zz_solve :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__zz_solve :: IMatrix -> IMatrix -> IO IMatrix casadi__IMatrix__zz_solve x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_solve errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_solve :: IMatrixClass a => a -> IMatrix -> IO IMatrix imatrix_zz_solve x = casadi__IMatrix__zz_solve (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_sparsify__0" c_casadi__IMatrix__zz_sparsify__0 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__zz_sparsify__0 :: IMatrix -> IO IMatrix casadi__IMatrix__zz_sparsify__0 x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_sparsify__0 errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_sparsify__0 :: IMatrixClass a => a -> IO IMatrix imatrix_zz_sparsify__0 x = casadi__IMatrix__zz_sparsify__0 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_sparsify__1" c_casadi__IMatrix__zz_sparsify__1 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CDouble -> IO (Ptr IMatrix') casadi__IMatrix__zz_sparsify__1 :: IMatrix -> Double -> IO IMatrix casadi__IMatrix__zz_sparsify__1 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_sparsify__1 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_sparsify__1 :: IMatrixClass a => a -> Double -> IO IMatrix imatrix_zz_sparsify__1 x = casadi__IMatrix__zz_sparsify__1 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_sprank" c_casadi__IMatrix__zz_sprank :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt casadi__IMatrix__zz_sprank :: IMatrix -> IO Int casadi__IMatrix__zz_sprank x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_sprank errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_sprank :: IMatrixClass a => a -> IO Int imatrix_zz_sprank x = casadi__IMatrix__zz_sprank (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_spy" c_casadi__IMatrix__zz_spy :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__zz_spy :: IMatrix -> IO IMatrix casadi__IMatrix__zz_spy x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_spy errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_spy :: IMatrixClass a => a -> IO IMatrix imatrix_zz_spy x = casadi__IMatrix__zz_spy (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_sqrt" c_casadi__IMatrix__zz_sqrt :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__zz_sqrt :: IMatrix -> IO IMatrix casadi__IMatrix__zz_sqrt x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_sqrt errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_sqrt :: IMatrixClass a => a -> IO IMatrix imatrix_zz_sqrt x = casadi__IMatrix__zz_sqrt (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_substitute__0" c_casadi__IMatrix__zz_substitute__0 :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr IMatrix')) -> Ptr (StdVec (Ptr IMatrix')) -> Ptr (StdVec (Ptr IMatrix')) -> IO (Ptr (StdVec (Ptr IMatrix'))) casadi__IMatrix__zz_substitute__0 :: Vector IMatrix -> Vector IMatrix -> Vector IMatrix -> IO (Vector IMatrix) casadi__IMatrix__zz_substitute__0 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_substitute__0 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_substitute__0 :: Vector IMatrix -> Vector IMatrix -> Vector IMatrix -> IO (Vector IMatrix) imatrix_zz_substitute__0 = casadi__IMatrix__zz_substitute__0 -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_substitute__1" c_casadi__IMatrix__zz_substitute__1 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__zz_substitute__1 :: IMatrix -> IMatrix -> IMatrix -> IO IMatrix casadi__IMatrix__zz_substitute__1 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_substitute__1 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_substitute__1 :: IMatrixClass a => a -> IMatrix -> IMatrix -> IO IMatrix imatrix_zz_substitute__1 x = casadi__IMatrix__zz_substitute__1 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_substituteInPlace__0" c_casadi__IMatrix__zz_substituteInPlace__0 :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr IMatrix')) -> Ptr (StdVec (Ptr IMatrix')) -> Ptr (StdVec (Ptr IMatrix')) -> IO () casadi__IMatrix__zz_substituteInPlace__0 :: Vector IMatrix -> Vector IMatrix -> Vector IMatrix -> IO () casadi__IMatrix__zz_substituteInPlace__0 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_substituteInPlace__0 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_substituteInPlace__0 :: Vector IMatrix -> Vector IMatrix -> Vector IMatrix -> IO () imatrix_zz_substituteInPlace__0 = casadi__IMatrix__zz_substituteInPlace__0 -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_substituteInPlace__1" c_casadi__IMatrix__zz_substituteInPlace__1 :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr IMatrix')) -> Ptr (StdVec (Ptr IMatrix')) -> Ptr (StdVec (Ptr IMatrix')) -> CInt -> IO () casadi__IMatrix__zz_substituteInPlace__1 :: Vector IMatrix -> Vector IMatrix -> Vector IMatrix -> Bool -> IO () casadi__IMatrix__zz_substituteInPlace__1 x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_substituteInPlace__1 errStrPtrP x0' x1' x2' x3' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_substituteInPlace__1 :: Vector IMatrix -> Vector IMatrix -> Vector IMatrix -> Bool -> IO () imatrix_zz_substituteInPlace__1 = casadi__IMatrix__zz_substituteInPlace__1 -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_sumAll" c_casadi__IMatrix__zz_sumAll :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__zz_sumAll :: IMatrix -> IO IMatrix casadi__IMatrix__zz_sumAll x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_sumAll errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_sumAll :: IMatrixClass a => a -> IO IMatrix imatrix_zz_sumAll x = casadi__IMatrix__zz_sumAll (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_sumCols" c_casadi__IMatrix__zz_sumCols :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__zz_sumCols :: IMatrix -> IO IMatrix casadi__IMatrix__zz_sumCols x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_sumCols errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_sumCols :: IMatrixClass a => a -> IO IMatrix imatrix_zz_sumCols x = casadi__IMatrix__zz_sumCols (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_sumRows" c_casadi__IMatrix__zz_sumRows :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__zz_sumRows :: IMatrix -> IO IMatrix casadi__IMatrix__zz_sumRows x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_sumRows errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_sumRows :: IMatrixClass a => a -> IO IMatrix imatrix_zz_sumRows x = casadi__IMatrix__zz_sumRows (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_sum_square" c_casadi__IMatrix__zz_sum_square :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__zz_sum_square :: IMatrix -> IO IMatrix casadi__IMatrix__zz_sum_square x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_sum_square errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_sum_square :: IMatrixClass a => a -> IO IMatrix imatrix_zz_sum_square x = casadi__IMatrix__zz_sum_square (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_tan" c_casadi__IMatrix__zz_tan :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__zz_tan :: IMatrix -> IO IMatrix casadi__IMatrix__zz_tan x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_tan errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_tan :: IMatrixClass a => a -> IO IMatrix imatrix_zz_tan x = casadi__IMatrix__zz_tan (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_tangent" c_casadi__IMatrix__zz_tangent :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__zz_tangent :: IMatrix -> IMatrix -> IO IMatrix casadi__IMatrix__zz_tangent x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_tangent errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_tangent :: IMatrixClass a => a -> IMatrix -> IO IMatrix imatrix_zz_tangent x = casadi__IMatrix__zz_tangent (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_tanh" c_casadi__IMatrix__zz_tanh :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__zz_tanh :: IMatrix -> IO IMatrix casadi__IMatrix__zz_tanh x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_tanh errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_tanh :: IMatrixClass a => a -> IO IMatrix imatrix_zz_tanh x = casadi__IMatrix__zz_tanh (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_taylor__0" c_casadi__IMatrix__zz_taylor__0 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__zz_taylor__0 :: IMatrix -> IMatrix -> IO IMatrix casadi__IMatrix__zz_taylor__0 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_taylor__0 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_taylor__0 :: IMatrixClass a => a -> IMatrix -> IO IMatrix imatrix_zz_taylor__0 x = casadi__IMatrix__zz_taylor__0 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_taylor__1" c_casadi__IMatrix__zz_taylor__1 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__zz_taylor__1 :: IMatrix -> IMatrix -> IMatrix -> IO IMatrix casadi__IMatrix__zz_taylor__1 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_taylor__1 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_taylor__1 :: IMatrixClass a => a -> IMatrix -> IMatrix -> IO IMatrix imatrix_zz_taylor__1 x = casadi__IMatrix__zz_taylor__1 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_taylor__2" c_casadi__IMatrix__zz_taylor__2 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> IO (Ptr IMatrix') casadi__IMatrix__zz_taylor__2 :: IMatrix -> IMatrix -> IMatrix -> Int -> IO IMatrix casadi__IMatrix__zz_taylor__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__zz_taylor__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_zz_taylor__2 :: IMatrixClass a => a -> IMatrix -> IMatrix -> Int -> IO IMatrix imatrix_zz_taylor__2 x = casadi__IMatrix__zz_taylor__2 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_times" c_casadi__IMatrix__zz_times :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__zz_times :: IMatrix -> IMatrix -> IO IMatrix casadi__IMatrix__zz_times x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_times errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_times :: IMatrixClass a => a -> IMatrix -> IO IMatrix imatrix_zz_times x = casadi__IMatrix__zz_times (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_trace" c_casadi__IMatrix__zz_trace :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__zz_trace :: IMatrix -> IO IMatrix casadi__IMatrix__zz_trace x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_trace errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_trace :: IMatrixClass a => a -> IO IMatrix imatrix_zz_trace x = casadi__IMatrix__zz_trace (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_triangle" c_casadi__IMatrix__zz_triangle :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__zz_triangle :: IMatrix -> IO IMatrix casadi__IMatrix__zz_triangle x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_triangle errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_triangle :: IMatrixClass a => a -> IO IMatrix imatrix_zz_triangle x = casadi__IMatrix__zz_triangle (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_tril__0" c_casadi__IMatrix__zz_tril__0 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__zz_tril__0 :: IMatrix -> IO IMatrix casadi__IMatrix__zz_tril__0 x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_tril__0 errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_tril__0 :: IMatrixClass a => a -> IO IMatrix imatrix_zz_tril__0 x = casadi__IMatrix__zz_tril__0 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_tril__1" c_casadi__IMatrix__zz_tril__1 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> IO (Ptr IMatrix') casadi__IMatrix__zz_tril__1 :: IMatrix -> Bool -> IO IMatrix casadi__IMatrix__zz_tril__1 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_tril__1 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_tril__1 :: IMatrixClass a => a -> Bool -> IO IMatrix imatrix_zz_tril__1 x = casadi__IMatrix__zz_tril__1 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_tril2symm" c_casadi__IMatrix__zz_tril2symm :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__zz_tril2symm :: IMatrix -> IO IMatrix casadi__IMatrix__zz_tril2symm x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_tril2symm errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_tril2symm :: IMatrixClass a => a -> IO IMatrix imatrix_zz_tril2symm x = casadi__IMatrix__zz_tril2symm (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_triu__0" c_casadi__IMatrix__zz_triu__0 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__zz_triu__0 :: IMatrix -> IO IMatrix casadi__IMatrix__zz_triu__0 x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_triu__0 errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_triu__0 :: IMatrixClass a => a -> IO IMatrix imatrix_zz_triu__0 x = casadi__IMatrix__zz_triu__0 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_triu__1" c_casadi__IMatrix__zz_triu__1 :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> IO (Ptr IMatrix') casadi__IMatrix__zz_triu__1 :: IMatrix -> Bool -> IO IMatrix casadi__IMatrix__zz_triu__1 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_triu__1 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_triu__1 :: IMatrixClass a => a -> Bool -> IO IMatrix imatrix_zz_triu__1 x = casadi__IMatrix__zz_triu__1 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_triu2symm" c_casadi__IMatrix__zz_triu2symm :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__zz_triu2symm :: IMatrix -> IO IMatrix casadi__IMatrix__zz_triu2symm x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_triu2symm errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_triu2symm :: IMatrixClass a => a -> IO IMatrix imatrix_zz_triu2symm x = casadi__IMatrix__zz_triu2symm (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_unite" c_casadi__IMatrix__zz_unite :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__zz_unite :: IMatrix -> IMatrix -> IO IMatrix casadi__IMatrix__zz_unite x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_unite errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_unite :: IMatrixClass a => a -> IMatrix -> IO IMatrix imatrix_zz_unite x = casadi__IMatrix__zz_unite (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_vec" c_casadi__IMatrix__zz_vec :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__zz_vec :: IMatrix -> IO IMatrix casadi__IMatrix__zz_vec x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_vec errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_vec :: IMatrixClass a => a -> IO IMatrix imatrix_zz_vec x = casadi__IMatrix__zz_vec (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_vecNZ" c_casadi__IMatrix__zz_vecNZ :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') casadi__IMatrix__zz_vecNZ :: IMatrix -> IO IMatrix casadi__IMatrix__zz_vecNZ x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_vecNZ errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_vecNZ :: IMatrixClass a => a -> IO IMatrix imatrix_zz_vecNZ x = casadi__IMatrix__zz_vecNZ (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_vecNZcat" c_casadi__IMatrix__zz_vecNZcat :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr IMatrix')) -> IO (Ptr IMatrix') casadi__IMatrix__zz_vecNZcat :: Vector IMatrix -> IO IMatrix casadi__IMatrix__zz_vecNZcat x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_vecNZcat errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_vecNZcat :: Vector IMatrix -> IO IMatrix imatrix_zz_vecNZcat = casadi__IMatrix__zz_vecNZcat -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_veccat" c_casadi__IMatrix__zz_veccat :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr IMatrix')) -> IO (Ptr IMatrix') casadi__IMatrix__zz_veccat :: Vector IMatrix -> IO IMatrix casadi__IMatrix__zz_veccat x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_veccat errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_veccat :: Vector IMatrix -> IO IMatrix imatrix_zz_veccat = casadi__IMatrix__zz_veccat -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_vertcat" c_casadi__IMatrix__zz_vertcat :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr IMatrix')) -> IO (Ptr IMatrix') casadi__IMatrix__zz_vertcat :: Vector IMatrix -> IO IMatrix casadi__IMatrix__zz_vertcat x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_vertcat errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_vertcat :: Vector IMatrix -> IO IMatrix imatrix_zz_vertcat = casadi__IMatrix__zz_vertcat -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__zz_vertsplit" c_casadi__IMatrix__zz_vertsplit :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr IMatrix'))) casadi__IMatrix__zz_vertsplit :: IMatrix -> Vector Int -> IO (Vector IMatrix) casadi__IMatrix__zz_vertsplit x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__zz_vertsplit errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_zz_vertsplit :: IMatrixClass a => a -> Vector Int -> IO (Vector IMatrix) imatrix_zz_vertsplit x = casadi__IMatrix__zz_vertsplit (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__getRepresentation" c_casadi__IMatrix__getRepresentation :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr StdString) casadi__IMatrix__getRepresentation :: IMatrix -> IO String casadi__IMatrix__getRepresentation x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__getRepresentation errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_getRepresentation :: IMatrixClass a => a -> IO String imatrix_getRepresentation x = casadi__IMatrix__getRepresentation (castIMatrix x) -- direct wrapper foreign import ccall unsafe "casadi__IMatrix__getDescription" c_casadi__IMatrix__getDescription :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr StdString) casadi__IMatrix__getDescription :: IMatrix -> IO String casadi__IMatrix__getDescription x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__IMatrix__getDescription errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper imatrix_getDescription :: IMatrixClass a => a -> IO String imatrix_getDescription x = casadi__IMatrix__getDescription (castIMatrix x)