{-# OPTIONS_GHC -Wall #-} {-# OPTIONS_GHC -fno-warn-unused-imports #-} {-# OPTIONS_GHC -fno-warn-orphans #-} {-# Language ForeignFunctionInterface #-} {-# Language FlexibleInstances #-} {-# Language MultiParamTypeClasses #-} module Casadi.Core.Classes.MX ( MX, MXClass(..), mx_T, mx__0, mx__1, mx__2, mx__3, mx__4, mx__5, mx__6, mx__7, mx___nonzero__, mx_append, mx_appendColumns, mx_attachAssert__0, mx_attachAssert__1, mx_binary, mx_colind, mx_dimString, mx_enlarge__0, mx_enlarge__1, mx_erase__0, mx_erase__1, mx_erase__2, mx_erase__3, mx_eye, mx_find__0, mx_find__1, mx_getColind, mx_getDep__0, mx_getDep__1, mx_getEqualityCheckingDepth, mx_getEvaluationOutput, mx_getFunction__0, mx_getFunction__1, mx_getMatrixValue, mx_getNZ__0, mx_getNZ__1, mx_getName, mx_getNdeps, mx_getOp, mx_getOutput__0, mx_getOutput__1, mx_getPrimitives, mx_getRow, mx_getSparsity, mx_getTemp, mx_getValue, mx_get__0, mx_get__1, mx_get__2, mx_get__3, mx_get__4, mx_get__5, mx_get__6, mx_hasDuplicates, mx_inf__0, mx_inf__1, mx_inf__2, mx_inf__3, mx_inf__4, mx_isBinary, mx_isCommutative, mx_isConstant, mx_isEvaluation, mx_isEvaluationOutput, mx_isIdentity, mx_isMinusOne, mx_isMultiplication, mx_isNorm, mx_isOne, mx_isOperation, mx_isRegular, mx_isSymbolic, mx_isTranspose, mx_isUnary, mx_isValidInput, mx_isZero, mx_iscolumn, mx_isdense, mx_isempty__0, mx_isempty__1, mx_isrow, mx_isscalar__0, mx_isscalar__1, mx_issquare, mx_istril, mx_istriu, mx_isvector, mx_joinPrimitives, mx_lift, mx_makeDense__0, mx_makeDense__1, mx_mapping, mx_monitor, mx_nOut, mx_nan__0, mx_nan__1, mx_nan__2, mx_nan__3, mx_nan__4, mx_nnz, mx_numFunctions, mx_numPrimitives, mx_numel__0, mx_numel__1, mx_ones__0, mx_ones__1, mx_ones__2, mx_ones__3, mx_ones__4, mx_operator_minus, mx_printme, mx_resetInput, mx_row, mx_setEqualityCheckingDepth__0, mx_setEqualityCheckingDepth__1, mx_setNZ__0, mx_setNZ__1, mx_setTemp, mx_set__0, mx_set__1, mx_set__2, mx_set__3, mx_set__4, mx_set__5, mx_set__6, mx_shape__0, mx_shape__1, mx_size, mx_size1, mx_size2, mx_sizeD, mx_sizeL, mx_sizeU, mx_sparse__0, mx_sparse__1, mx_sparse__2, mx_sparse__3, mx_sparse__4, mx_sparsity, mx_splitPrimitives, mx_sym__0, mx_sym__1, mx_sym__2, mx_sym__3, mx_sym__4, mx_sym__5, mx_sym__6, mx_sym__7, mx_sym__8, mx_unary, mx_zeros__0, mx_zeros__1, mx_zeros__2, mx_zeros__3, mx_zeros__4, mx_zz_project__0, mx_zz_project__1, ) where import Prelude hiding ( Functor ) import Data.Vector ( Vector ) import qualified Data.Map as M 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.FormatException ( formatException ) import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream' import Casadi.Internal.Marshal ( Marshal(..), withMarshal ) import Casadi.Internal.WrapReturn ( WrapReturn(..) ) import Casadi.Core.Data import Casadi.Core.Enums -- direct wrapper foreign import ccall unsafe "casadi__MX__CONSTRUCTOR__0" c_casadi__MX__CONSTRUCTOR__0 :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr MX') casadi__MX__CONSTRUCTOR__0 :: DMatrix -> IO MX casadi__MX__CONSTRUCTOR__0 x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__CONSTRUCTOR__0 errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx__0 :: DMatrix -> IO MX mx__0 = casadi__MX__CONSTRUCTOR__0 -- direct wrapper foreign import ccall unsafe "casadi__MX__CONSTRUCTOR__1" c_casadi__MX__CONSTRUCTOR__1 :: Ptr (Ptr StdString) -> Ptr (StdVec CDouble) -> IO (Ptr MX') casadi__MX__CONSTRUCTOR__1 :: Vector Double -> IO MX casadi__MX__CONSTRUCTOR__1 x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__CONSTRUCTOR__1 errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx__1 :: Vector Double -> IO MX mx__1 = casadi__MX__CONSTRUCTOR__1 -- direct wrapper foreign import ccall unsafe "casadi__MX__CONSTRUCTOR__2" c_casadi__MX__CONSTRUCTOR__2 :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') casadi__MX__CONSTRUCTOR__2 :: MX -> IO MX casadi__MX__CONSTRUCTOR__2 x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__CONSTRUCTOR__2 errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx__2 :: MX -> IO MX mx__2 = casadi__MX__CONSTRUCTOR__2 -- direct wrapper foreign import ccall unsafe "casadi__MX__CONSTRUCTOR__3" c_casadi__MX__CONSTRUCTOR__3 :: Ptr (Ptr StdString) -> CDouble -> IO (Ptr MX') casadi__MX__CONSTRUCTOR__3 :: Double -> IO MX casadi__MX__CONSTRUCTOR__3 x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__CONSTRUCTOR__3 errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx__3 :: Double -> IO MX mx__3 = casadi__MX__CONSTRUCTOR__3 -- direct wrapper foreign import ccall unsafe "casadi__MX__CONSTRUCTOR__4" c_casadi__MX__CONSTRUCTOR__4 :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr MX' -> IO (Ptr MX') casadi__MX__CONSTRUCTOR__4 :: Sparsity -> MX -> IO MX casadi__MX__CONSTRUCTOR__4 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__CONSTRUCTOR__4 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx__4 :: Sparsity -> MX -> IO MX mx__4 = casadi__MX__CONSTRUCTOR__4 -- direct wrapper foreign import ccall unsafe "casadi__MX__CONSTRUCTOR__5" c_casadi__MX__CONSTRUCTOR__5 :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr MX') casadi__MX__CONSTRUCTOR__5 :: Sparsity -> IO MX casadi__MX__CONSTRUCTOR__5 x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__CONSTRUCTOR__5 errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx__5 :: Sparsity -> IO MX mx__5 = casadi__MX__CONSTRUCTOR__5 -- direct wrapper foreign import ccall unsafe "casadi__MX__CONSTRUCTOR__6" c_casadi__MX__CONSTRUCTOR__6 :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr MX') casadi__MX__CONSTRUCTOR__6 :: Int -> Int -> IO MX casadi__MX__CONSTRUCTOR__6 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__CONSTRUCTOR__6 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx__6 :: Int -> Int -> IO MX mx__6 = casadi__MX__CONSTRUCTOR__6 -- direct wrapper foreign import ccall unsafe "casadi__MX__CONSTRUCTOR__7" c_casadi__MX__CONSTRUCTOR__7 :: Ptr (Ptr StdString) -> IO (Ptr MX') casadi__MX__CONSTRUCTOR__7 :: IO MX casadi__MX__CONSTRUCTOR__7 = do errStrPtrP <- new nullPtr ret <- c_casadi__MX__CONSTRUCTOR__7 errStrPtrP errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx__7 :: IO MX mx__7 = casadi__MX__CONSTRUCTOR__7 -- direct wrapper foreign import ccall unsafe "casadi__MX__T" c_casadi__MX__T :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') casadi__MX__T :: MX -> IO MX casadi__MX__T x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__T errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_T :: MXClass a => a -> IO MX mx_T x = casadi__MX__T (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX____nonzero__" c_casadi__MX____nonzero__ :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt casadi__MX____nonzero__ :: MX -> IO Bool casadi__MX____nonzero__ x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX____nonzero__ errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx___nonzero__ :: MXClass a => a -> IO Bool mx___nonzero__ x = casadi__MX____nonzero__ (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__append" c_casadi__MX__append :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO () casadi__MX__append :: MX -> MX -> IO () casadi__MX__append x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__append errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_append :: MXClass a => a -> MX -> IO () mx_append x = casadi__MX__append (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__appendColumns" c_casadi__MX__appendColumns :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO () casadi__MX__appendColumns :: MX -> MX -> IO () casadi__MX__appendColumns x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__appendColumns errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_appendColumns :: MXClass a => a -> MX -> IO () mx_appendColumns x = casadi__MX__appendColumns (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__attachAssert__0" c_casadi__MX__attachAssert__0 :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX') casadi__MX__attachAssert__0 :: MX -> MX -> IO MX casadi__MX__attachAssert__0 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__attachAssert__0 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_attachAssert__0 :: MXClass a => a -> MX -> IO MX mx_attachAssert__0 x = casadi__MX__attachAssert__0 (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__attachAssert__1" c_casadi__MX__attachAssert__1 :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> Ptr StdString -> IO (Ptr MX') casadi__MX__attachAssert__1 :: MX -> MX -> String -> IO MX casadi__MX__attachAssert__1 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__attachAssert__1 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_attachAssert__1 :: MXClass a => a -> MX -> String -> IO MX mx_attachAssert__1 x = casadi__MX__attachAssert__1 (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__binary" c_casadi__MX__binary :: Ptr (Ptr StdString) -> CInt -> Ptr MX' -> Ptr MX' -> IO (Ptr MX') casadi__MX__binary :: Int -> MX -> MX -> IO MX casadi__MX__binary x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__binary errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_binary :: Int -> MX -> MX -> IO MX mx_binary = casadi__MX__binary -- direct wrapper foreign import ccall unsafe "casadi__MX__colind" c_casadi__MX__colind :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> IO CInt casadi__MX__colind :: MX -> Int -> IO Int casadi__MX__colind x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__colind errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_colind :: MXClass a => a -> Int -> IO Int mx_colind x = casadi__MX__colind (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__dimString" c_casadi__MX__dimString :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr StdString) casadi__MX__dimString :: MX -> IO String casadi__MX__dimString x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__dimString errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_dimString :: MXClass a => a -> IO String mx_dimString x = casadi__MX__dimString (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__enlarge__0" c_casadi__MX__enlarge__0 :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> CInt -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO () casadi__MX__enlarge__0 :: MX -> Int -> Int -> Vector Int -> Vector Int -> IO () casadi__MX__enlarge__0 x0 x1 x2 x3 x4 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> withMarshal x4 $ \x4' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__enlarge__0 errStrPtrP x0' x1' x2' x3' x4' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_enlarge__0 :: MXClass a => a -> Int -> Int -> Vector Int -> Vector Int -> IO () mx_enlarge__0 x = casadi__MX__enlarge__0 (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__enlarge__1" c_casadi__MX__enlarge__1 :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> CInt -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> CInt -> IO () casadi__MX__enlarge__1 :: MX -> Int -> Int -> Vector Int -> Vector Int -> Bool -> IO () casadi__MX__enlarge__1 x0 x1 x2 x3 x4 x5 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> withMarshal x4 $ \x4' -> withMarshal x5 $ \x5' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__enlarge__1 errStrPtrP x0' x1' x2' x3' x4' x5' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_enlarge__1 :: MXClass a => a -> Int -> Int -> Vector Int -> Vector Int -> Bool -> IO () mx_enlarge__1 x = casadi__MX__enlarge__1 (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__erase__0" c_casadi__MX__erase__0 :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (StdVec CInt) -> IO () casadi__MX__erase__0 :: MX -> Vector Int -> IO () casadi__MX__erase__0 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__erase__0 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_erase__0 :: MXClass a => a -> Vector Int -> IO () mx_erase__0 x = casadi__MX__erase__0 (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__erase__1" c_casadi__MX__erase__1 :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (StdVec CInt) -> CInt -> IO () casadi__MX__erase__1 :: MX -> Vector Int -> Bool -> IO () casadi__MX__erase__1 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__erase__1 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_erase__1 :: MXClass a => a -> Vector Int -> Bool -> IO () mx_erase__1 x = casadi__MX__erase__1 (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__erase__2" c_casadi__MX__erase__2 :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO () casadi__MX__erase__2 :: MX -> Vector Int -> Vector Int -> IO () casadi__MX__erase__2 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__erase__2 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_erase__2 :: MXClass a => a -> Vector Int -> Vector Int -> IO () mx_erase__2 x = casadi__MX__erase__2 (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__erase__3" c_casadi__MX__erase__3 :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> CInt -> IO () casadi__MX__erase__3 :: MX -> Vector Int -> Vector Int -> Bool -> IO () casadi__MX__erase__3 x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__erase__3 errStrPtrP x0' x1' x2' x3' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_erase__3 :: MXClass a => a -> Vector Int -> Vector Int -> Bool -> IO () mx_erase__3 x = casadi__MX__erase__3 (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__eye" c_casadi__MX__eye :: Ptr (Ptr StdString) -> CInt -> IO (Ptr MX') casadi__MX__eye :: Int -> IO MX casadi__MX__eye x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__eye errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_eye :: Int -> IO MX mx_eye = casadi__MX__eye -- direct wrapper foreign import ccall unsafe "casadi__MX__find__0" c_casadi__MX__find__0 :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr (StdVec CInt)) casadi__MX__find__0 :: MX -> IO (Vector Int) casadi__MX__find__0 x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__find__0 errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_find__0 :: MXClass a => a -> IO (Vector Int) mx_find__0 x = casadi__MX__find__0 (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__find__1" c_casadi__MX__find__1 :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> IO (Ptr (StdVec CInt)) casadi__MX__find__1 :: MX -> Bool -> IO (Vector Int) casadi__MX__find__1 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__find__1 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_find__1 :: MXClass a => a -> Bool -> IO (Vector Int) mx_find__1 x = casadi__MX__find__1 (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__get__0" c_casadi__MX__get__0 :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> Ptr IMatrix' -> Ptr IMatrix' -> IO () casadi__MX__get__0 :: MX -> MX -> Bool -> IMatrix -> IMatrix -> IO () casadi__MX__get__0 x0 x1 x2 x3 x4 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> withMarshal x4 $ \x4' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__get__0 errStrPtrP x0' x1' x2' x3' x4' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_get__0 :: MXClass a => a -> MX -> Bool -> IMatrix -> IMatrix -> IO () mx_get__0 x = casadi__MX__get__0 (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__get__1" c_casadi__MX__get__1 :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> Ptr IMatrix' -> Ptr Slice' -> IO () casadi__MX__get__1 :: MX -> MX -> Bool -> IMatrix -> Slice -> IO () casadi__MX__get__1 x0 x1 x2 x3 x4 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> withMarshal x4 $ \x4' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__get__1 errStrPtrP x0' x1' x2' x3' x4' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_get__1 :: MXClass a => a -> MX -> Bool -> IMatrix -> Slice -> IO () mx_get__1 x = casadi__MX__get__1 (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__get__2" c_casadi__MX__get__2 :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> Ptr Slice' -> Ptr IMatrix' -> IO () casadi__MX__get__2 :: MX -> MX -> Bool -> Slice -> IMatrix -> IO () casadi__MX__get__2 x0 x1 x2 x3 x4 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> withMarshal x4 $ \x4' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__get__2 errStrPtrP x0' x1' x2' x3' x4' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_get__2 :: MXClass a => a -> MX -> Bool -> Slice -> IMatrix -> IO () mx_get__2 x = casadi__MX__get__2 (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__get__3" c_casadi__MX__get__3 :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> Ptr Slice' -> Ptr Slice' -> IO () casadi__MX__get__3 :: MX -> MX -> Bool -> Slice -> Slice -> IO () casadi__MX__get__3 x0 x1 x2 x3 x4 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> withMarshal x4 $ \x4' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__get__3 errStrPtrP x0' x1' x2' x3' x4' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_get__3 :: MXClass a => a -> MX -> Bool -> Slice -> Slice -> IO () mx_get__3 x = casadi__MX__get__3 (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__get__4" c_casadi__MX__get__4 :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> Ptr Sparsity' -> IO () casadi__MX__get__4 :: MX -> MX -> Bool -> Sparsity -> IO () casadi__MX__get__4 x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__get__4 errStrPtrP x0' x1' x2' x3' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_get__4 :: MXClass a => a -> MX -> Bool -> Sparsity -> IO () mx_get__4 x = casadi__MX__get__4 (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__get__5" c_casadi__MX__get__5 :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> Ptr IMatrix' -> IO () casadi__MX__get__5 :: MX -> MX -> Bool -> IMatrix -> IO () casadi__MX__get__5 x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__get__5 errStrPtrP x0' x1' x2' x3' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_get__5 :: MXClass a => a -> MX -> Bool -> IMatrix -> IO () mx_get__5 x = casadi__MX__get__5 (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__get__6" c_casadi__MX__get__6 :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> Ptr Slice' -> IO () casadi__MX__get__6 :: MX -> MX -> Bool -> Slice -> IO () casadi__MX__get__6 x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__get__6 errStrPtrP x0' x1' x2' x3' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_get__6 :: MXClass a => a -> MX -> Bool -> Slice -> IO () mx_get__6 x = casadi__MX__get__6 (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__getColind" c_casadi__MX__getColind :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr (StdVec CInt)) casadi__MX__getColind :: MX -> IO (Vector Int) casadi__MX__getColind x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__getColind errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_getColind :: MXClass a => a -> IO (Vector Int) mx_getColind x = casadi__MX__getColind (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__getDep__0" c_casadi__MX__getDep__0 :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') casadi__MX__getDep__0 :: MX -> IO MX casadi__MX__getDep__0 x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__getDep__0 errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_getDep__0 :: MXClass a => a -> IO MX mx_getDep__0 x = casadi__MX__getDep__0 (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__getDep__1" c_casadi__MX__getDep__1 :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> IO (Ptr MX') casadi__MX__getDep__1 :: MX -> Int -> IO MX casadi__MX__getDep__1 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__getDep__1 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_getDep__1 :: MXClass a => a -> Int -> IO MX mx_getDep__1 x = casadi__MX__getDep__1 (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__getEqualityCheckingDepth" c_casadi__MX__getEqualityCheckingDepth :: Ptr (Ptr StdString) -> IO CInt casadi__MX__getEqualityCheckingDepth :: IO Int casadi__MX__getEqualityCheckingDepth = do errStrPtrP <- new nullPtr ret <- c_casadi__MX__getEqualityCheckingDepth errStrPtrP errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_getEqualityCheckingDepth :: IO Int mx_getEqualityCheckingDepth = casadi__MX__getEqualityCheckingDepth -- direct wrapper foreign import ccall unsafe "casadi__MX__getEvaluationOutput" c_casadi__MX__getEvaluationOutput :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt casadi__MX__getEvaluationOutput :: MX -> IO Int casadi__MX__getEvaluationOutput x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__getEvaluationOutput errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_getEvaluationOutput :: MXClass a => a -> IO Int mx_getEvaluationOutput x = casadi__MX__getEvaluationOutput (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__getFunction__0" c_casadi__MX__getFunction__0 :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr Function') casadi__MX__getFunction__0 :: MX -> IO Function casadi__MX__getFunction__0 x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__getFunction__0 errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_getFunction__0 :: MXClass a => a -> IO Function mx_getFunction__0 x = casadi__MX__getFunction__0 (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__getFunction__1" c_casadi__MX__getFunction__1 :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> IO (Ptr Function') casadi__MX__getFunction__1 :: MX -> Int -> IO Function casadi__MX__getFunction__1 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__getFunction__1 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_getFunction__1 :: MXClass a => a -> Int -> IO Function mx_getFunction__1 x = casadi__MX__getFunction__1 (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__getMatrixValue" c_casadi__MX__getMatrixValue :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr DMatrix') casadi__MX__getMatrixValue :: MX -> IO DMatrix casadi__MX__getMatrixValue x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__getMatrixValue errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_getMatrixValue :: MXClass a => a -> IO DMatrix mx_getMatrixValue x = casadi__MX__getMatrixValue (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__getNZ__0" c_casadi__MX__getNZ__0 :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> Ptr IMatrix' -> IO () casadi__MX__getNZ__0 :: MX -> MX -> Bool -> IMatrix -> IO () casadi__MX__getNZ__0 x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__getNZ__0 errStrPtrP x0' x1' x2' x3' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_getNZ__0 :: MXClass a => a -> MX -> Bool -> IMatrix -> IO () mx_getNZ__0 x = casadi__MX__getNZ__0 (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__getNZ__1" c_casadi__MX__getNZ__1 :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> Ptr Slice' -> IO () casadi__MX__getNZ__1 :: MX -> MX -> Bool -> Slice -> IO () casadi__MX__getNZ__1 x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__getNZ__1 errStrPtrP x0' x1' x2' x3' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_getNZ__1 :: MXClass a => a -> MX -> Bool -> Slice -> IO () mx_getNZ__1 x = casadi__MX__getNZ__1 (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__getName" c_casadi__MX__getName :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr StdString) casadi__MX__getName :: MX -> IO String casadi__MX__getName x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__getName errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_getName :: MXClass a => a -> IO String mx_getName x = casadi__MX__getName (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__getNdeps" c_casadi__MX__getNdeps :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt casadi__MX__getNdeps :: MX -> IO Int casadi__MX__getNdeps x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__getNdeps errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_getNdeps :: MXClass a => a -> IO Int mx_getNdeps x = casadi__MX__getNdeps (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__getOp" c_casadi__MX__getOp :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt casadi__MX__getOp :: MX -> IO Int casadi__MX__getOp x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__getOp errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_getOp :: MXClass a => a -> IO Int mx_getOp x = casadi__MX__getOp (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__getOutput__0" c_casadi__MX__getOutput__0 :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') casadi__MX__getOutput__0 :: MX -> IO MX casadi__MX__getOutput__0 x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__getOutput__0 errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_getOutput__0 :: MXClass a => a -> IO MX mx_getOutput__0 x = casadi__MX__getOutput__0 (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__getOutput__1" c_casadi__MX__getOutput__1 :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> IO (Ptr MX') casadi__MX__getOutput__1 :: MX -> Int -> IO MX casadi__MX__getOutput__1 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__getOutput__1 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_getOutput__1 :: MXClass a => a -> Int -> IO MX mx_getOutput__1 x = casadi__MX__getOutput__1 (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__getPrimitives" c_casadi__MX__getPrimitives :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr (StdVec (Ptr MX'))) casadi__MX__getPrimitives :: MX -> IO (Vector MX) casadi__MX__getPrimitives x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__getPrimitives errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_getPrimitives :: MXClass a => a -> IO (Vector MX) mx_getPrimitives x = casadi__MX__getPrimitives (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__getRow" c_casadi__MX__getRow :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr (StdVec CInt)) casadi__MX__getRow :: MX -> IO (Vector Int) casadi__MX__getRow x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__getRow errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_getRow :: MXClass a => a -> IO (Vector Int) mx_getRow x = casadi__MX__getRow (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__getSparsity" c_casadi__MX__getSparsity :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr Sparsity') casadi__MX__getSparsity :: MX -> IO Sparsity casadi__MX__getSparsity x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__getSparsity errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_getSparsity :: MXClass a => a -> IO Sparsity mx_getSparsity x = casadi__MX__getSparsity (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__getTemp" c_casadi__MX__getTemp :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt casadi__MX__getTemp :: MX -> IO Int casadi__MX__getTemp x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__getTemp errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_getTemp :: MXClass a => a -> IO Int mx_getTemp x = casadi__MX__getTemp (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__getValue" c_casadi__MX__getValue :: Ptr (Ptr StdString) -> Ptr MX' -> IO CDouble casadi__MX__getValue :: MX -> IO Double casadi__MX__getValue x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__getValue errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_getValue :: MXClass a => a -> IO Double mx_getValue x = casadi__MX__getValue (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__hasDuplicates" c_casadi__MX__hasDuplicates :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt casadi__MX__hasDuplicates :: MX -> IO Bool casadi__MX__hasDuplicates x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__hasDuplicates errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_hasDuplicates :: MXClass a => a -> IO Bool mx_hasDuplicates x = casadi__MX__hasDuplicates (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__inf__0" c_casadi__MX__inf__0 :: Ptr (Ptr StdString) -> Ptr (StdPair CInt CInt) -> IO (Ptr MX') casadi__MX__inf__0 :: (Int, Int) -> IO MX casadi__MX__inf__0 x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__inf__0 errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_inf__0 :: (Int, Int) -> IO MX mx_inf__0 = casadi__MX__inf__0 -- direct wrapper foreign import ccall unsafe "casadi__MX__inf__1" c_casadi__MX__inf__1 :: Ptr (Ptr StdString) -> IO (Ptr MX') casadi__MX__inf__1 :: IO MX casadi__MX__inf__1 = do errStrPtrP <- new nullPtr ret <- c_casadi__MX__inf__1 errStrPtrP errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_inf__1 :: IO MX mx_inf__1 = casadi__MX__inf__1 -- direct wrapper foreign import ccall unsafe "casadi__MX__inf__2" c_casadi__MX__inf__2 :: Ptr (Ptr StdString) -> CInt -> IO (Ptr MX') casadi__MX__inf__2 :: Int -> IO MX casadi__MX__inf__2 x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__inf__2 errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_inf__2 :: Int -> IO MX mx_inf__2 = casadi__MX__inf__2 -- direct wrapper foreign import ccall unsafe "casadi__MX__inf__3" c_casadi__MX__inf__3 :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr MX') casadi__MX__inf__3 :: Int -> Int -> IO MX casadi__MX__inf__3 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__inf__3 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_inf__3 :: Int -> Int -> IO MX mx_inf__3 = casadi__MX__inf__3 -- direct wrapper foreign import ccall unsafe "casadi__MX__inf__4" c_casadi__MX__inf__4 :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr MX') casadi__MX__inf__4 :: Sparsity -> IO MX casadi__MX__inf__4 x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__inf__4 errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_inf__4 :: Sparsity -> IO MX mx_inf__4 = casadi__MX__inf__4 -- direct wrapper foreign import ccall unsafe "casadi__MX__isBinary" c_casadi__MX__isBinary :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt casadi__MX__isBinary :: MX -> IO Bool casadi__MX__isBinary x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__isBinary errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_isBinary :: MXClass a => a -> IO Bool mx_isBinary x = casadi__MX__isBinary (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__isCommutative" c_casadi__MX__isCommutative :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt casadi__MX__isCommutative :: MX -> IO Bool casadi__MX__isCommutative x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__isCommutative errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_isCommutative :: MXClass a => a -> IO Bool mx_isCommutative x = casadi__MX__isCommutative (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__isConstant" c_casadi__MX__isConstant :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt casadi__MX__isConstant :: MX -> IO Bool casadi__MX__isConstant x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__isConstant errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_isConstant :: MXClass a => a -> IO Bool mx_isConstant x = casadi__MX__isConstant (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__isEvaluation" c_casadi__MX__isEvaluation :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt casadi__MX__isEvaluation :: MX -> IO Bool casadi__MX__isEvaluation x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__isEvaluation errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_isEvaluation :: MXClass a => a -> IO Bool mx_isEvaluation x = casadi__MX__isEvaluation (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__isEvaluationOutput" c_casadi__MX__isEvaluationOutput :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt casadi__MX__isEvaluationOutput :: MX -> IO Bool casadi__MX__isEvaluationOutput x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__isEvaluationOutput errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_isEvaluationOutput :: MXClass a => a -> IO Bool mx_isEvaluationOutput x = casadi__MX__isEvaluationOutput (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__isIdentity" c_casadi__MX__isIdentity :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt casadi__MX__isIdentity :: MX -> IO Bool casadi__MX__isIdentity x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__isIdentity errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_isIdentity :: MXClass a => a -> IO Bool mx_isIdentity x = casadi__MX__isIdentity (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__isMinusOne" c_casadi__MX__isMinusOne :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt casadi__MX__isMinusOne :: MX -> IO Bool casadi__MX__isMinusOne x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__isMinusOne errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_isMinusOne :: MXClass a => a -> IO Bool mx_isMinusOne x = casadi__MX__isMinusOne (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__isMultiplication" c_casadi__MX__isMultiplication :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt casadi__MX__isMultiplication :: MX -> IO Bool casadi__MX__isMultiplication x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__isMultiplication errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_isMultiplication :: MXClass a => a -> IO Bool mx_isMultiplication x = casadi__MX__isMultiplication (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__isNorm" c_casadi__MX__isNorm :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt casadi__MX__isNorm :: MX -> IO Bool casadi__MX__isNorm x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__isNorm errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_isNorm :: MXClass a => a -> IO Bool mx_isNorm x = casadi__MX__isNorm (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__isOne" c_casadi__MX__isOne :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt casadi__MX__isOne :: MX -> IO Bool casadi__MX__isOne x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__isOne errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_isOne :: MXClass a => a -> IO Bool mx_isOne x = casadi__MX__isOne (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__isOperation" c_casadi__MX__isOperation :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> IO CInt casadi__MX__isOperation :: MX -> Int -> IO Bool casadi__MX__isOperation x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__isOperation errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_isOperation :: MXClass a => a -> Int -> IO Bool mx_isOperation x = casadi__MX__isOperation (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__isRegular" c_casadi__MX__isRegular :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt casadi__MX__isRegular :: MX -> IO Bool casadi__MX__isRegular x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__isRegular errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_isRegular :: MXClass a => a -> IO Bool mx_isRegular x = casadi__MX__isRegular (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__isSymbolic" c_casadi__MX__isSymbolic :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt casadi__MX__isSymbolic :: MX -> IO Bool casadi__MX__isSymbolic x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__isSymbolic errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_isSymbolic :: MXClass a => a -> IO Bool mx_isSymbolic x = casadi__MX__isSymbolic (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__isTranspose" c_casadi__MX__isTranspose :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt casadi__MX__isTranspose :: MX -> IO Bool casadi__MX__isTranspose x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__isTranspose errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_isTranspose :: MXClass a => a -> IO Bool mx_isTranspose x = casadi__MX__isTranspose (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__isUnary" c_casadi__MX__isUnary :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt casadi__MX__isUnary :: MX -> IO Bool casadi__MX__isUnary x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__isUnary errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_isUnary :: MXClass a => a -> IO Bool mx_isUnary x = casadi__MX__isUnary (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__isValidInput" c_casadi__MX__isValidInput :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt casadi__MX__isValidInput :: MX -> IO Bool casadi__MX__isValidInput x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__isValidInput errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_isValidInput :: MXClass a => a -> IO Bool mx_isValidInput x = casadi__MX__isValidInput (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__isZero" c_casadi__MX__isZero :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt casadi__MX__isZero :: MX -> IO Bool casadi__MX__isZero x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__isZero errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_isZero :: MXClass a => a -> IO Bool mx_isZero x = casadi__MX__isZero (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__iscolumn" c_casadi__MX__iscolumn :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt casadi__MX__iscolumn :: MX -> IO Bool casadi__MX__iscolumn x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__iscolumn errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_iscolumn :: MXClass a => a -> IO Bool mx_iscolumn x = casadi__MX__iscolumn (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__isdense" c_casadi__MX__isdense :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt casadi__MX__isdense :: MX -> IO Bool casadi__MX__isdense x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__isdense errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_isdense :: MXClass a => a -> IO Bool mx_isdense x = casadi__MX__isdense (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__isempty__0" c_casadi__MX__isempty__0 :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt casadi__MX__isempty__0 :: MX -> IO Bool casadi__MX__isempty__0 x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__isempty__0 errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_isempty__0 :: MXClass a => a -> IO Bool mx_isempty__0 x = casadi__MX__isempty__0 (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__isempty__1" c_casadi__MX__isempty__1 :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> IO CInt casadi__MX__isempty__1 :: MX -> Bool -> IO Bool casadi__MX__isempty__1 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__isempty__1 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_isempty__1 :: MXClass a => a -> Bool -> IO Bool mx_isempty__1 x = casadi__MX__isempty__1 (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__isrow" c_casadi__MX__isrow :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt casadi__MX__isrow :: MX -> IO Bool casadi__MX__isrow x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__isrow errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_isrow :: MXClass a => a -> IO Bool mx_isrow x = casadi__MX__isrow (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__isscalar__0" c_casadi__MX__isscalar__0 :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt casadi__MX__isscalar__0 :: MX -> IO Bool casadi__MX__isscalar__0 x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__isscalar__0 errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_isscalar__0 :: MXClass a => a -> IO Bool mx_isscalar__0 x = casadi__MX__isscalar__0 (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__isscalar__1" c_casadi__MX__isscalar__1 :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> IO CInt casadi__MX__isscalar__1 :: MX -> Bool -> IO Bool casadi__MX__isscalar__1 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__isscalar__1 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_isscalar__1 :: MXClass a => a -> Bool -> IO Bool mx_isscalar__1 x = casadi__MX__isscalar__1 (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__issquare" c_casadi__MX__issquare :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt casadi__MX__issquare :: MX -> IO Bool casadi__MX__issquare x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__issquare errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_issquare :: MXClass a => a -> IO Bool mx_issquare x = casadi__MX__issquare (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__istril" c_casadi__MX__istril :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt casadi__MX__istril :: MX -> IO Bool casadi__MX__istril x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__istril errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_istril :: MXClass a => a -> IO Bool mx_istril x = casadi__MX__istril (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__istriu" c_casadi__MX__istriu :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt casadi__MX__istriu :: MX -> IO Bool casadi__MX__istriu x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__istriu errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_istriu :: MXClass a => a -> IO Bool mx_istriu x = casadi__MX__istriu (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__isvector" c_casadi__MX__isvector :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt casadi__MX__isvector :: MX -> IO Bool casadi__MX__isvector x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__isvector errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_isvector :: MXClass a => a -> IO Bool mx_isvector x = casadi__MX__isvector (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__joinPrimitives" c_casadi__MX__joinPrimitives :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (StdVec (Ptr MX')) -> IO (Ptr MX') casadi__MX__joinPrimitives :: MX -> Vector MX -> IO MX casadi__MX__joinPrimitives x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__joinPrimitives errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_joinPrimitives :: MXClass a => a -> Vector MX -> IO MX mx_joinPrimitives x = casadi__MX__joinPrimitives (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__lift" c_casadi__MX__lift :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO () casadi__MX__lift :: MX -> MX -> IO () casadi__MX__lift x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__lift errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_lift :: MXClass a => a -> MX -> IO () mx_lift x = casadi__MX__lift (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__makeDense__0" c_casadi__MX__makeDense__0 :: Ptr (Ptr StdString) -> Ptr MX' -> IO () casadi__MX__makeDense__0 :: MX -> IO () casadi__MX__makeDense__0 x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__makeDense__0 errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_makeDense__0 :: MXClass a => a -> IO () mx_makeDense__0 x = casadi__MX__makeDense__0 (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__makeDense__1" c_casadi__MX__makeDense__1 :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO () casadi__MX__makeDense__1 :: MX -> MX -> IO () casadi__MX__makeDense__1 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__makeDense__1 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_makeDense__1 :: MXClass a => a -> MX -> IO () mx_makeDense__1 x = casadi__MX__makeDense__1 (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__mapping" c_casadi__MX__mapping :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr IMatrix') casadi__MX__mapping :: MX -> IO IMatrix casadi__MX__mapping x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__mapping errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_mapping :: MXClass a => a -> IO IMatrix mx_mapping x = casadi__MX__mapping (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__monitor" c_casadi__MX__monitor :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr StdString -> IO (Ptr MX') casadi__MX__monitor :: MX -> String -> IO MX casadi__MX__monitor x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__monitor errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_monitor :: MXClass a => a -> String -> IO MX mx_monitor x = casadi__MX__monitor (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__nOut" c_casadi__MX__nOut :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt casadi__MX__nOut :: MX -> IO Int casadi__MX__nOut x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__nOut errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_nOut :: MXClass a => a -> IO Int mx_nOut x = casadi__MX__nOut (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__nan__0" c_casadi__MX__nan__0 :: Ptr (Ptr StdString) -> Ptr (StdPair CInt CInt) -> IO (Ptr MX') casadi__MX__nan__0 :: (Int, Int) -> IO MX casadi__MX__nan__0 x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__nan__0 errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_nan__0 :: (Int, Int) -> IO MX mx_nan__0 = casadi__MX__nan__0 -- direct wrapper foreign import ccall unsafe "casadi__MX__nan__1" c_casadi__MX__nan__1 :: Ptr (Ptr StdString) -> IO (Ptr MX') casadi__MX__nan__1 :: IO MX casadi__MX__nan__1 = do errStrPtrP <- new nullPtr ret <- c_casadi__MX__nan__1 errStrPtrP errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_nan__1 :: IO MX mx_nan__1 = casadi__MX__nan__1 -- direct wrapper foreign import ccall unsafe "casadi__MX__nan__2" c_casadi__MX__nan__2 :: Ptr (Ptr StdString) -> CInt -> IO (Ptr MX') casadi__MX__nan__2 :: Int -> IO MX casadi__MX__nan__2 x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__nan__2 errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_nan__2 :: Int -> IO MX mx_nan__2 = casadi__MX__nan__2 -- direct wrapper foreign import ccall unsafe "casadi__MX__nan__3" c_casadi__MX__nan__3 :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr MX') casadi__MX__nan__3 :: Int -> Int -> IO MX casadi__MX__nan__3 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__nan__3 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_nan__3 :: Int -> Int -> IO MX mx_nan__3 = casadi__MX__nan__3 -- direct wrapper foreign import ccall unsafe "casadi__MX__nan__4" c_casadi__MX__nan__4 :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr MX') casadi__MX__nan__4 :: Sparsity -> IO MX casadi__MX__nan__4 x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__nan__4 errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_nan__4 :: Sparsity -> IO MX mx_nan__4 = casadi__MX__nan__4 -- direct wrapper foreign import ccall unsafe "casadi__MX__nnz" c_casadi__MX__nnz :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt casadi__MX__nnz :: MX -> IO Int casadi__MX__nnz x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__nnz errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_nnz :: MXClass a => a -> IO Int mx_nnz x = casadi__MX__nnz (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__numFunctions" c_casadi__MX__numFunctions :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt casadi__MX__numFunctions :: MX -> IO Int casadi__MX__numFunctions x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__numFunctions errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_numFunctions :: MXClass a => a -> IO Int mx_numFunctions x = casadi__MX__numFunctions (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__numPrimitives" c_casadi__MX__numPrimitives :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt casadi__MX__numPrimitives :: MX -> IO Int casadi__MX__numPrimitives x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__numPrimitives errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_numPrimitives :: MXClass a => a -> IO Int mx_numPrimitives x = casadi__MX__numPrimitives (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__numel__0" c_casadi__MX__numel__0 :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> IO CInt casadi__MX__numel__0 :: MX -> Int -> IO Int casadi__MX__numel__0 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__numel__0 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_numel__0 :: MXClass a => a -> Int -> IO Int mx_numel__0 x = casadi__MX__numel__0 (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__numel__1" c_casadi__MX__numel__1 :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt casadi__MX__numel__1 :: MX -> IO Int casadi__MX__numel__1 x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__numel__1 errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_numel__1 :: MXClass a => a -> IO Int mx_numel__1 x = casadi__MX__numel__1 (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__ones__0" c_casadi__MX__ones__0 :: Ptr (Ptr StdString) -> Ptr (StdPair CInt CInt) -> IO (Ptr MX') casadi__MX__ones__0 :: (Int, Int) -> IO MX casadi__MX__ones__0 x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__ones__0 errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_ones__0 :: (Int, Int) -> IO MX mx_ones__0 = casadi__MX__ones__0 -- direct wrapper foreign import ccall unsafe "casadi__MX__ones__1" c_casadi__MX__ones__1 :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr MX') casadi__MX__ones__1 :: Sparsity -> IO MX casadi__MX__ones__1 x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__ones__1 errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_ones__1 :: Sparsity -> IO MX mx_ones__1 = casadi__MX__ones__1 -- direct wrapper foreign import ccall unsafe "casadi__MX__ones__2" c_casadi__MX__ones__2 :: Ptr (Ptr StdString) -> IO (Ptr MX') casadi__MX__ones__2 :: IO MX casadi__MX__ones__2 = do errStrPtrP <- new nullPtr ret <- c_casadi__MX__ones__2 errStrPtrP errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_ones__2 :: IO MX mx_ones__2 = casadi__MX__ones__2 -- direct wrapper foreign import ccall unsafe "casadi__MX__ones__3" c_casadi__MX__ones__3 :: Ptr (Ptr StdString) -> CInt -> IO (Ptr MX') casadi__MX__ones__3 :: Int -> IO MX casadi__MX__ones__3 x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__ones__3 errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_ones__3 :: Int -> IO MX mx_ones__3 = casadi__MX__ones__3 -- direct wrapper foreign import ccall unsafe "casadi__MX__ones__4" c_casadi__MX__ones__4 :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr MX') casadi__MX__ones__4 :: Int -> Int -> IO MX casadi__MX__ones__4 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__ones__4 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_ones__4 :: Int -> Int -> IO MX mx_ones__4 = casadi__MX__ones__4 -- direct wrapper foreign import ccall unsafe "casadi__MX__operator_minus" c_casadi__MX__operator_minus :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') casadi__MX__operator_minus :: MX -> IO MX casadi__MX__operator_minus x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__operator_minus errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_operator_minus :: MXClass a => a -> IO MX mx_operator_minus x = casadi__MX__operator_minus (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__printme" c_casadi__MX__printme :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX') casadi__MX__printme :: MX -> MX -> IO MX casadi__MX__printme x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__printme errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_printme :: MXClass a => a -> MX -> IO MX mx_printme x = casadi__MX__printme (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__resetInput" c_casadi__MX__resetInput :: Ptr (Ptr StdString) -> Ptr MX' -> IO () casadi__MX__resetInput :: MX -> IO () casadi__MX__resetInput x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__resetInput errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_resetInput :: MXClass a => a -> IO () mx_resetInput x = casadi__MX__resetInput (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__row" c_casadi__MX__row :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> IO CInt casadi__MX__row :: MX -> Int -> IO Int casadi__MX__row x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__row errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_row :: MXClass a => a -> Int -> IO Int mx_row x = casadi__MX__row (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__set__0" c_casadi__MX__set__0 :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> Ptr IMatrix' -> Ptr IMatrix' -> IO () casadi__MX__set__0 :: MX -> MX -> Bool -> IMatrix -> IMatrix -> IO () casadi__MX__set__0 x0 x1 x2 x3 x4 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> withMarshal x4 $ \x4' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__set__0 errStrPtrP x0' x1' x2' x3' x4' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_set__0 :: MXClass a => a -> MX -> Bool -> IMatrix -> IMatrix -> IO () mx_set__0 x = casadi__MX__set__0 (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__set__1" c_casadi__MX__set__1 :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> Ptr IMatrix' -> Ptr Slice' -> IO () casadi__MX__set__1 :: MX -> MX -> Bool -> IMatrix -> Slice -> IO () casadi__MX__set__1 x0 x1 x2 x3 x4 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> withMarshal x4 $ \x4' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__set__1 errStrPtrP x0' x1' x2' x3' x4' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_set__1 :: MXClass a => a -> MX -> Bool -> IMatrix -> Slice -> IO () mx_set__1 x = casadi__MX__set__1 (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__set__2" c_casadi__MX__set__2 :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> Ptr Slice' -> Ptr IMatrix' -> IO () casadi__MX__set__2 :: MX -> MX -> Bool -> Slice -> IMatrix -> IO () casadi__MX__set__2 x0 x1 x2 x3 x4 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> withMarshal x4 $ \x4' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__set__2 errStrPtrP x0' x1' x2' x3' x4' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_set__2 :: MXClass a => a -> MX -> Bool -> Slice -> IMatrix -> IO () mx_set__2 x = casadi__MX__set__2 (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__set__3" c_casadi__MX__set__3 :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> Ptr Slice' -> Ptr Slice' -> IO () casadi__MX__set__3 :: MX -> MX -> Bool -> Slice -> Slice -> IO () casadi__MX__set__3 x0 x1 x2 x3 x4 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> withMarshal x4 $ \x4' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__set__3 errStrPtrP x0' x1' x2' x3' x4' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_set__3 :: MXClass a => a -> MX -> Bool -> Slice -> Slice -> IO () mx_set__3 x = casadi__MX__set__3 (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__set__4" c_casadi__MX__set__4 :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> Ptr Sparsity' -> IO () casadi__MX__set__4 :: MX -> MX -> Bool -> Sparsity -> IO () casadi__MX__set__4 x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__set__4 errStrPtrP x0' x1' x2' x3' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_set__4 :: MXClass a => a -> MX -> Bool -> Sparsity -> IO () mx_set__4 x = casadi__MX__set__4 (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__set__5" c_casadi__MX__set__5 :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> Ptr IMatrix' -> IO () casadi__MX__set__5 :: MX -> MX -> Bool -> IMatrix -> IO () casadi__MX__set__5 x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__set__5 errStrPtrP x0' x1' x2' x3' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_set__5 :: MXClass a => a -> MX -> Bool -> IMatrix -> IO () mx_set__5 x = casadi__MX__set__5 (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__set__6" c_casadi__MX__set__6 :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> Ptr Slice' -> IO () casadi__MX__set__6 :: MX -> MX -> Bool -> Slice -> IO () casadi__MX__set__6 x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__set__6 errStrPtrP x0' x1' x2' x3' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_set__6 :: MXClass a => a -> MX -> Bool -> Slice -> IO () mx_set__6 x = casadi__MX__set__6 (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__setEqualityCheckingDepth__0" c_casadi__MX__setEqualityCheckingDepth__0 :: Ptr (Ptr StdString) -> IO () casadi__MX__setEqualityCheckingDepth__0 :: IO () casadi__MX__setEqualityCheckingDepth__0 = do errStrPtrP <- new nullPtr ret <- c_casadi__MX__setEqualityCheckingDepth__0 errStrPtrP errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_setEqualityCheckingDepth__0 :: IO () mx_setEqualityCheckingDepth__0 = casadi__MX__setEqualityCheckingDepth__0 -- direct wrapper foreign import ccall unsafe "casadi__MX__setEqualityCheckingDepth__1" c_casadi__MX__setEqualityCheckingDepth__1 :: Ptr (Ptr StdString) -> CInt -> IO () casadi__MX__setEqualityCheckingDepth__1 :: Int -> IO () casadi__MX__setEqualityCheckingDepth__1 x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__setEqualityCheckingDepth__1 errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_setEqualityCheckingDepth__1 :: Int -> IO () mx_setEqualityCheckingDepth__1 = casadi__MX__setEqualityCheckingDepth__1 -- direct wrapper foreign import ccall unsafe "casadi__MX__setNZ__0" c_casadi__MX__setNZ__0 :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> Ptr IMatrix' -> IO () casadi__MX__setNZ__0 :: MX -> MX -> Bool -> IMatrix -> IO () casadi__MX__setNZ__0 x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__setNZ__0 errStrPtrP x0' x1' x2' x3' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_setNZ__0 :: MXClass a => a -> MX -> Bool -> IMatrix -> IO () mx_setNZ__0 x = casadi__MX__setNZ__0 (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__setNZ__1" c_casadi__MX__setNZ__1 :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> Ptr Slice' -> IO () casadi__MX__setNZ__1 :: MX -> MX -> Bool -> Slice -> IO () casadi__MX__setNZ__1 x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__setNZ__1 errStrPtrP x0' x1' x2' x3' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_setNZ__1 :: MXClass a => a -> MX -> Bool -> Slice -> IO () mx_setNZ__1 x = casadi__MX__setNZ__1 (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__setTemp" c_casadi__MX__setTemp :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> IO () casadi__MX__setTemp :: MX -> Int -> IO () casadi__MX__setTemp x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__setTemp errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_setTemp :: MXClass a => a -> Int -> IO () mx_setTemp x = casadi__MX__setTemp (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__shape__0" c_casadi__MX__shape__0 :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> IO CInt casadi__MX__shape__0 :: MX -> Int -> IO Int casadi__MX__shape__0 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__shape__0 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_shape__0 :: MXClass a => a -> Int -> IO Int mx_shape__0 x = casadi__MX__shape__0 (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__shape__1" c_casadi__MX__shape__1 :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr (StdPair CInt CInt)) casadi__MX__shape__1 :: MX -> IO (Int, Int) casadi__MX__shape__1 x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__shape__1 errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_shape__1 :: MXClass a => a -> IO (Int, Int) mx_shape__1 x = casadi__MX__shape__1 (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__size" c_casadi__MX__size :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt casadi__MX__size :: MX -> IO Int casadi__MX__size x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__size errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_size :: MXClass a => a -> IO Int mx_size x = casadi__MX__size (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__size1" c_casadi__MX__size1 :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt casadi__MX__size1 :: MX -> IO Int casadi__MX__size1 x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__size1 errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_size1 :: MXClass a => a -> IO Int mx_size1 x = casadi__MX__size1 (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__size2" c_casadi__MX__size2 :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt casadi__MX__size2 :: MX -> IO Int casadi__MX__size2 x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__size2 errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_size2 :: MXClass a => a -> IO Int mx_size2 x = casadi__MX__size2 (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__sizeD" c_casadi__MX__sizeD :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt casadi__MX__sizeD :: MX -> IO Int casadi__MX__sizeD x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__sizeD errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_sizeD :: MXClass a => a -> IO Int mx_sizeD x = casadi__MX__sizeD (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__sizeL" c_casadi__MX__sizeL :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt casadi__MX__sizeL :: MX -> IO Int casadi__MX__sizeL x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__sizeL errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_sizeL :: MXClass a => a -> IO Int mx_sizeL x = casadi__MX__sizeL (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__sizeU" c_casadi__MX__sizeU :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt casadi__MX__sizeU :: MX -> IO Int casadi__MX__sizeU x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__sizeU errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_sizeU :: MXClass a => a -> IO Int mx_sizeU x = casadi__MX__sizeU (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__sparse__0" c_casadi__MX__sparse__0 :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr MX' -> IO (Ptr MX') casadi__MX__sparse__0 :: Sparsity -> MX -> IO MX casadi__MX__sparse__0 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__sparse__0 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_sparse__0 :: Sparsity -> MX -> IO MX mx_sparse__0 = casadi__MX__sparse__0 -- direct wrapper foreign import ccall unsafe "casadi__MX__sparse__1" c_casadi__MX__sparse__1 :: Ptr (Ptr StdString) -> Ptr (StdPair CInt CInt) -> IO (Ptr MX') casadi__MX__sparse__1 :: (Int, Int) -> IO MX casadi__MX__sparse__1 x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__sparse__1 errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_sparse__1 :: (Int, Int) -> IO MX mx_sparse__1 = casadi__MX__sparse__1 -- direct wrapper foreign import ccall unsafe "casadi__MX__sparse__2" c_casadi__MX__sparse__2 :: Ptr (Ptr StdString) -> IO (Ptr MX') casadi__MX__sparse__2 :: IO MX casadi__MX__sparse__2 = do errStrPtrP <- new nullPtr ret <- c_casadi__MX__sparse__2 errStrPtrP errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_sparse__2 :: IO MX mx_sparse__2 = casadi__MX__sparse__2 -- direct wrapper foreign import ccall unsafe "casadi__MX__sparse__3" c_casadi__MX__sparse__3 :: Ptr (Ptr StdString) -> CInt -> IO (Ptr MX') casadi__MX__sparse__3 :: Int -> IO MX casadi__MX__sparse__3 x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__sparse__3 errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_sparse__3 :: Int -> IO MX mx_sparse__3 = casadi__MX__sparse__3 -- direct wrapper foreign import ccall unsafe "casadi__MX__sparse__4" c_casadi__MX__sparse__4 :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr MX') casadi__MX__sparse__4 :: Int -> Int -> IO MX casadi__MX__sparse__4 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__sparse__4 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_sparse__4 :: Int -> Int -> IO MX mx_sparse__4 = casadi__MX__sparse__4 -- direct wrapper foreign import ccall unsafe "casadi__MX__sparsity" c_casadi__MX__sparsity :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr Sparsity') casadi__MX__sparsity :: MX -> IO Sparsity casadi__MX__sparsity x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__sparsity errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_sparsity :: MXClass a => a -> IO Sparsity mx_sparsity x = casadi__MX__sparsity (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__splitPrimitives" c_casadi__MX__splitPrimitives :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr (StdVec (Ptr MX'))) casadi__MX__splitPrimitives :: MX -> MX -> IO (Vector MX) casadi__MX__splitPrimitives x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__splitPrimitives errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_splitPrimitives :: MXClass a => a -> MX -> IO (Vector MX) mx_splitPrimitives x = casadi__MX__splitPrimitives (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__sym__0" c_casadi__MX__sym__0 :: Ptr (Ptr StdString) -> Ptr StdString -> CInt -> CInt -> CInt -> CInt -> IO (Ptr (StdVec (Ptr (StdVec (Ptr MX'))))) casadi__MX__sym__0 :: String -> Int -> Int -> Int -> Int -> IO (Vector (Vector MX)) casadi__MX__sym__0 x0 x1 x2 x3 x4 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> withMarshal x4 $ \x4' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__sym__0 errStrPtrP x0' x1' x2' x3' x4' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_sym__0 :: String -> Int -> Int -> Int -> Int -> IO (Vector (Vector MX)) mx_sym__0 = casadi__MX__sym__0 -- direct wrapper foreign import ccall unsafe "casadi__MX__sym__1" c_casadi__MX__sym__1 :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> CInt -> CInt -> IO (Ptr (StdVec (Ptr (StdVec (Ptr MX'))))) casadi__MX__sym__1 :: String -> Sparsity -> Int -> Int -> IO (Vector (Vector MX)) casadi__MX__sym__1 x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__sym__1 errStrPtrP x0' x1' x2' x3' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_sym__1 :: String -> Sparsity -> Int -> Int -> IO (Vector (Vector MX)) mx_sym__1 = casadi__MX__sym__1 -- direct wrapper foreign import ccall unsafe "casadi__MX__sym__2" c_casadi__MX__sym__2 :: Ptr (Ptr StdString) -> Ptr StdString -> CInt -> CInt -> CInt -> IO (Ptr (StdVec (Ptr MX'))) casadi__MX__sym__2 :: String -> Int -> Int -> Int -> IO (Vector MX) casadi__MX__sym__2 x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__sym__2 errStrPtrP x0' x1' x2' x3' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_sym__2 :: String -> Int -> Int -> Int -> IO (Vector MX) mx_sym__2 = casadi__MX__sym__2 -- direct wrapper foreign import ccall unsafe "casadi__MX__sym__3" c_casadi__MX__sym__3 :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> CInt -> IO (Ptr (StdVec (Ptr MX'))) casadi__MX__sym__3 :: String -> Sparsity -> Int -> IO (Vector MX) casadi__MX__sym__3 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__sym__3 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_sym__3 :: String -> Sparsity -> Int -> IO (Vector MX) mx_sym__3 = casadi__MX__sym__3 -- direct wrapper foreign import ccall unsafe "casadi__MX__sym__4" c_casadi__MX__sym__4 :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr MX') casadi__MX__sym__4 :: String -> Sparsity -> IO MX casadi__MX__sym__4 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__sym__4 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_sym__4 :: String -> Sparsity -> IO MX mx_sym__4 = casadi__MX__sym__4 -- direct wrapper foreign import ccall unsafe "casadi__MX__sym__5" c_casadi__MX__sym__5 :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr (StdPair CInt CInt) -> IO (Ptr MX') casadi__MX__sym__5 :: String -> (Int, Int) -> IO MX casadi__MX__sym__5 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__sym__5 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_sym__5 :: String -> (Int, Int) -> IO MX mx_sym__5 = casadi__MX__sym__5 -- direct wrapper foreign import ccall unsafe "casadi__MX__sym__6" c_casadi__MX__sym__6 :: Ptr (Ptr StdString) -> Ptr StdString -> IO (Ptr MX') casadi__MX__sym__6 :: String -> IO MX casadi__MX__sym__6 x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__sym__6 errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_sym__6 :: String -> IO MX mx_sym__6 = casadi__MX__sym__6 -- direct wrapper foreign import ccall unsafe "casadi__MX__sym__7" c_casadi__MX__sym__7 :: Ptr (Ptr StdString) -> Ptr StdString -> CInt -> IO (Ptr MX') casadi__MX__sym__7 :: String -> Int -> IO MX casadi__MX__sym__7 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__sym__7 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_sym__7 :: String -> Int -> IO MX mx_sym__7 = casadi__MX__sym__7 -- direct wrapper foreign import ccall unsafe "casadi__MX__sym__8" c_casadi__MX__sym__8 :: Ptr (Ptr StdString) -> Ptr StdString -> CInt -> CInt -> IO (Ptr MX') casadi__MX__sym__8 :: String -> Int -> Int -> IO MX casadi__MX__sym__8 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__sym__8 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_sym__8 :: String -> Int -> Int -> IO MX mx_sym__8 = casadi__MX__sym__8 -- direct wrapper foreign import ccall unsafe "casadi__MX__unary" c_casadi__MX__unary :: Ptr (Ptr StdString) -> CInt -> Ptr MX' -> IO (Ptr MX') casadi__MX__unary :: Int -> MX -> IO MX casadi__MX__unary x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__unary errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_unary :: Int -> MX -> IO MX mx_unary = casadi__MX__unary -- direct wrapper foreign import ccall unsafe "casadi__MX__zeros__0" c_casadi__MX__zeros__0 :: Ptr (Ptr StdString) -> Ptr (StdPair CInt CInt) -> IO (Ptr MX') casadi__MX__zeros__0 :: (Int, Int) -> IO MX casadi__MX__zeros__0 x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__zeros__0 errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_zeros__0 :: (Int, Int) -> IO MX mx_zeros__0 = casadi__MX__zeros__0 -- direct wrapper foreign import ccall unsafe "casadi__MX__zeros__1" c_casadi__MX__zeros__1 :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr MX') casadi__MX__zeros__1 :: Sparsity -> IO MX casadi__MX__zeros__1 x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__zeros__1 errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_zeros__1 :: Sparsity -> IO MX mx_zeros__1 = casadi__MX__zeros__1 -- direct wrapper foreign import ccall unsafe "casadi__MX__zeros__2" c_casadi__MX__zeros__2 :: Ptr (Ptr StdString) -> IO (Ptr MX') casadi__MX__zeros__2 :: IO MX casadi__MX__zeros__2 = do errStrPtrP <- new nullPtr ret <- c_casadi__MX__zeros__2 errStrPtrP errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_zeros__2 :: IO MX mx_zeros__2 = casadi__MX__zeros__2 -- direct wrapper foreign import ccall unsafe "casadi__MX__zeros__3" c_casadi__MX__zeros__3 :: Ptr (Ptr StdString) -> CInt -> IO (Ptr MX') casadi__MX__zeros__3 :: Int -> IO MX casadi__MX__zeros__3 x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__zeros__3 errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_zeros__3 :: Int -> IO MX mx_zeros__3 = casadi__MX__zeros__3 -- direct wrapper foreign import ccall unsafe "casadi__MX__zeros__4" c_casadi__MX__zeros__4 :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr MX') casadi__MX__zeros__4 :: Int -> Int -> IO MX casadi__MX__zeros__4 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__zeros__4 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_zeros__4 :: Int -> Int -> IO MX mx_zeros__4 = casadi__MX__zeros__4 -- direct wrapper foreign import ccall unsafe "casadi__MX__zz_project__0" c_casadi__MX__zz_project__0 :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr Sparsity' -> IO (Ptr MX') casadi__MX__zz_project__0 :: MX -> Sparsity -> IO MX casadi__MX__zz_project__0 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__zz_project__0 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_zz_project__0 :: MXClass a => a -> Sparsity -> IO MX mx_zz_project__0 x = casadi__MX__zz_project__0 (castMX x) -- direct wrapper foreign import ccall unsafe "casadi__MX__zz_project__1" c_casadi__MX__zz_project__1 :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr Sparsity' -> CInt -> IO (Ptr MX') casadi__MX__zz_project__1 :: MX -> Sparsity -> Bool -> IO MX casadi__MX__zz_project__1 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr ret <- c_casadi__MX__zz_project__1 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper mx_zz_project__1 :: MXClass a => a -> Sparsity -> Bool -> IO MX mx_zz_project__1 x = casadi__MX__zz_project__1 (castMX x)