{-# OPTIONS_GHC -Wall #-} {-# OPTIONS_GHC -fno-warn-unused-imports #-} {-# OPTIONS_GHC -fno-warn-orphans #-} {-# Language ForeignFunctionInterface #-} {-# Language FlexibleInstances #-} {-# Language MultiParamTypeClasses #-} module Casadi.Wrappers.Classes.MX ( MX, MXClass(..), mx, mx', mx'', mx''', mx'''', mx''''', mx'''''', mx''''''', mx'''''''', mx___add__, mx___constpow__, mx___copysign__, mx___div__, mx___eq__, mx___hash__, mx___le__, mx___lt__, mx___mpower__, mx___mrdivide__, mx___mul__, mx___ne__, mx___nonzero__, mx___pow__, mx___sub__, mx___truediv__, mx_addToSum, mx_append, mx_appendColumns, mx_arccos, mx_arccosh, mx_arcsin, mx_arcsinh, mx_arctan, mx_arctan2, mx_arctanh, mx_attachAssert, mx_attachAssert', mx_binary, mx_ceil, mx_constpow, mx_cos, mx_cosh, mx_densify, mx_densify', mx_enlarge, mx_erase, mx_erf, mx_erfinv, mx_exp, mx_eye, mx_fabs, mx_floor, mx_fmax, mx_fmin, mx_getDep, mx_getDep', mx_getEqualityCheckingDepth, mx_getEvaluationOutput, mx_getFunction, mx_getMatrixValue, mx_getMaxNumCallsInPrint, mx_getNZ, mx_getNZ', mx_getNZ'', mx_getNZ''', mx_getName, mx_getNdeps, mx_getNumOutputs, mx_getOp, mx_getOutput, mx_getOutput', mx_getTemp, mx_getValue, mx_if_else_zero, mx_indexed_assignment, mx_indexed_assignment', mx_indexed_assignment'', mx_indexed_assignment''', mx_indexed_assignment'''', mx_indexed_assignment''''', mx_indexed_assignment'''''', mx_indexed_assignment''''''', mx_indexed_assignment'''''''', mx_indexed_assignment''''''''', mx_indexed_one_based_assignment, mx_indexed_one_based_assignment', mx_indexed_zero_based_assignment, mx_indexed_zero_based_assignment', mx_indexed_zero_based_assignment'', mx_inf, mx_inf', mx_inf'', mx_inf''', mx_inner_prod, mx_isBinary, mx_isCommutative, mx_isConstant, mx_isEqual, mx_isEqual', mx_isEvaluation, mx_isEvaluationOutput, mx_isIdentity, mx_isMinusOne, mx_isMultiplication, mx_isNorm, mx_isOne, mx_isOperation, mx_isRegular, mx_isSymbolic, mx_isSymbolicSparse, mx_isTranspose, mx_isUnary, mx_isZero, mx_lift, mx_log, mx_log10, mx_logic_and, mx_logic_not, mx_logic_or, mx_mapping, mx_mul, mx_mul', mx_mul_full, mx_mul_full', mx_nan, mx_nan', mx_nan'', mx_nan''', mx_nz_indexed_assignment, mx_nz_indexed_assignment', mx_nz_indexed_one_based_assignment, mx_nz_indexed_zero_based_assignment, mx_operator_minus, mx_outer_prod, mx_printme, mx_repmat, mx_repmat', mx_repmat'', mx_setEqualityCheckingDepth, mx_setEqualityCheckingDepth', mx_setMaxNumCallsInPrint, mx_setMaxNumCallsInPrint', mx_setNZ, mx_setNZ', mx_setNZ'', mx_setNZ''', mx_setSparse, mx_setSparse', mx_setSub, mx_setSub', mx_setSub'', mx_setSub''', mx_setSub'''', mx_setSub''''', mx_setSub'''''', mx_setSub''''''', mx_setSub'''''''', mx_setSub''''''''', mx_setTemp, mx_sign, mx_sin, mx_sinh, mx_sparsityRef, mx_sqrt, mx_tan, mx_tanh, mx_trans, mx_unary, ) where import Prelude hiding ( Functor ) import Data.Vector ( Vector ) import Foreign.C.Types import Foreign.Ptr ( Ptr ) import Foreign.ForeignPtr ( newForeignPtr ) import System.IO.Unsafe ( unsafePerformIO ) -- for show instances import Casadi.Wrappers.Classes.PrintableObject import Casadi.Wrappers.CToolsInstances ( ) import Casadi.Wrappers.Data import Casadi.Wrappers.Enums import Casadi.MarshalTypes ( CppVec, StdString' ) -- StdOstream' import Casadi.Marshal ( Marshal(..), withMarshal ) import Casadi.WrapReturn ( WrapReturn(..) ) instance Show MX where show = unsafePerformIO . printableObject_getDescription -- direct wrapper foreign import ccall unsafe "CasADi__MX____nonzero__" c_CasADi__MX____nonzero__ :: Ptr MX' -> IO CInt casADi__MX____nonzero__ :: MX -> IO Bool casADi__MX____nonzero__ x0 = withMarshal x0 $ \x0' -> c_CasADi__MX____nonzero__ x0' >>= wrapReturn -- classy wrapper {-| >Returns the truth value of an MX expression. -} mx___nonzero__ :: MXClass a => a -> IO Bool mx___nonzero__ x = casADi__MX____nonzero__ (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__nz_indexed_one_based_assignment" c_CasADi__MX__nz_indexed_one_based_assignment :: Ptr MX' -> CInt -> Ptr MX' -> IO () casADi__MX__nz_indexed_one_based_assignment :: MX -> Int -> MX -> IO () casADi__MX__nz_indexed_one_based_assignment x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__MX__nz_indexed_one_based_assignment x0' x1' x2' >>= wrapReturn -- classy wrapper {-| >set a non-zero -} mx_nz_indexed_one_based_assignment :: MXClass a => a -> Int -> MX -> IO () mx_nz_indexed_one_based_assignment x = casADi__MX__nz_indexed_one_based_assignment (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__nz_indexed_zero_based_assignment" c_CasADi__MX__nz_indexed_zero_based_assignment :: Ptr MX' -> CInt -> Ptr MX' -> IO () casADi__MX__nz_indexed_zero_based_assignment :: MX -> Int -> MX -> IO () casADi__MX__nz_indexed_zero_based_assignment x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__MX__nz_indexed_zero_based_assignment x0' x1' x2' >>= wrapReturn -- classy wrapper {-| >Indexing for interfaced languages. > >get a non-zero -} mx_nz_indexed_zero_based_assignment :: MXClass a => a -> Int -> MX -> IO () mx_nz_indexed_zero_based_assignment x = casADi__MX__nz_indexed_zero_based_assignment (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__nz_indexed_assignment" c_CasADi__MX__nz_indexed_assignment :: Ptr MX' -> Ptr IndexList' -> Ptr MX' -> IO () casADi__MX__nz_indexed_assignment :: MX -> IndexList -> MX -> IO () casADi__MX__nz_indexed_assignment x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__MX__nz_indexed_assignment x0' x1' x2' >>= wrapReturn -- classy wrapper {-| >Indexing for interfaced languages. > >get a non-zero -} mx_nz_indexed_assignment :: MXClass a => a -> IndexList -> MX -> IO () mx_nz_indexed_assignment x = casADi__MX__nz_indexed_assignment (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__nz_indexed_assignment_TIC" c_CasADi__MX__nz_indexed_assignment_TIC :: Ptr MX' -> Ptr Slice' -> Ptr MX' -> IO () casADi__MX__nz_indexed_assignment' :: MX -> Slice -> MX -> IO () casADi__MX__nz_indexed_assignment' x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__MX__nz_indexed_assignment_TIC x0' x1' x2' >>= wrapReturn -- classy wrapper mx_nz_indexed_assignment' :: MXClass a => a -> Slice -> MX -> IO () mx_nz_indexed_assignment' x = casADi__MX__nz_indexed_assignment' (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__indexed_one_based_assignment" c_CasADi__MX__indexed_one_based_assignment :: Ptr MX' -> CInt -> CInt -> Ptr MX' -> IO () casADi__MX__indexed_one_based_assignment :: MX -> Int -> Int -> MX -> IO () casADi__MX__indexed_one_based_assignment x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> c_CasADi__MX__indexed_one_based_assignment x0' x1' x2' x3' >>= wrapReturn -- classy wrapper {-| >> void CasADi::MX::indexed_one_based_assignment(int rr, int cc, const MX &m) >------------------------------------------------------------------------ > >set a matrix element -} mx_indexed_one_based_assignment :: MXClass a => a -> Int -> Int -> MX -> IO () mx_indexed_one_based_assignment x = casADi__MX__indexed_one_based_assignment (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__indexed_zero_based_assignment" c_CasADi__MX__indexed_zero_based_assignment :: Ptr MX' -> CInt -> CInt -> Ptr MX' -> IO () casADi__MX__indexed_zero_based_assignment :: MX -> Int -> Int -> MX -> IO () casADi__MX__indexed_zero_based_assignment x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> c_CasADi__MX__indexed_zero_based_assignment x0' x1' x2' x3' >>= wrapReturn -- classy wrapper {-| >> void CasADi::MX::indexed_zero_based_assignment(int rr, int cc, const MX &m) > >> void CasADi::MX::indexed_zero_based_assignment(const Matrix< int > &k, const MX &m) >------------------------------------------------------------------------ > >Indexing for interfaced languages. > >get a non-zero -} mx_indexed_zero_based_assignment :: MXClass a => a -> Int -> Int -> MX -> IO () mx_indexed_zero_based_assignment x = casADi__MX__indexed_zero_based_assignment (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__indexed_assignment" c_CasADi__MX__indexed_assignment :: Ptr MX' -> Ptr IndexList' -> Ptr IndexList' -> Ptr MX' -> IO () casADi__MX__indexed_assignment :: MX -> IndexList -> IndexList -> MX -> IO () casADi__MX__indexed_assignment x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> c_CasADi__MX__indexed_assignment x0' x1' x2' x3' >>= wrapReturn -- classy wrapper {-| >> void CasADi::MX::indexed_assignment(const IndexList &rr, const IndexList &cc, const MX &m) > >> void CasADi::MX::indexed_assignment(const Slice &rr, const Slice &cc, const MX &m) > >> void CasADi::MX::indexed_assignment(const Sparsity &sp, const MX &m) > >> void CasADi::MX::indexed_assignment(const Matrix< int > &rr, const Slice &cc, const MX &m) > >> void CasADi::MX::indexed_assignment(const Slice &rr, const Matrix< int > &cc, const MX &m) > >> void CasADi::MX::indexed_assignment(const Matrix< int > &rr, const IndexList &cc, const MX &m) > >> void CasADi::MX::indexed_assignment(const IndexList &rr, const Matrix< int > &cc, const MX &m) > >> void CasADi::MX::indexed_assignment(const Matrix< int > &rr, const Matrix< int > &cc, const MX &m) >------------------------------------------------------------------------ > >Indexing for interfaced languages. > >get a non-zero -} mx_indexed_assignment :: MXClass a => a -> IndexList -> IndexList -> MX -> IO () mx_indexed_assignment x = casADi__MX__indexed_assignment (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__indexed_assignment_TIC" c_CasADi__MX__indexed_assignment_TIC :: Ptr MX' -> Ptr Slice' -> Ptr Slice' -> Ptr MX' -> IO () casADi__MX__indexed_assignment' :: MX -> Slice -> Slice -> MX -> IO () casADi__MX__indexed_assignment' x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> c_CasADi__MX__indexed_assignment_TIC x0' x1' x2' x3' >>= wrapReturn -- classy wrapper mx_indexed_assignment' :: MXClass a => a -> Slice -> Slice -> MX -> IO () mx_indexed_assignment' x = casADi__MX__indexed_assignment' (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__indexed_zero_based_assignment_TIC" c_CasADi__MX__indexed_zero_based_assignment_TIC :: Ptr MX' -> Ptr IMatrix' -> Ptr MX' -> IO () casADi__MX__indexed_zero_based_assignment' :: MX -> IMatrix -> MX -> IO () casADi__MX__indexed_zero_based_assignment' x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__MX__indexed_zero_based_assignment_TIC x0' x1' x2' >>= wrapReturn -- classy wrapper mx_indexed_zero_based_assignment' :: MXClass a => a -> IMatrix -> MX -> IO () mx_indexed_zero_based_assignment' x = casADi__MX__indexed_zero_based_assignment' (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__indexed_assignment_TIC_TIC" c_CasADi__MX__indexed_assignment_TIC_TIC :: Ptr MX' -> Ptr Sparsity' -> Ptr MX' -> IO () casADi__MX__indexed_assignment'' :: MX -> Sparsity -> MX -> IO () casADi__MX__indexed_assignment'' x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__MX__indexed_assignment_TIC_TIC x0' x1' x2' >>= wrapReturn -- classy wrapper mx_indexed_assignment'' :: MXClass a => a -> Sparsity -> MX -> IO () mx_indexed_assignment'' x = casADi__MX__indexed_assignment'' (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__indexed_assignment_TIC_TIC_TIC" c_CasADi__MX__indexed_assignment_TIC_TIC_TIC :: Ptr MX' -> Ptr IMatrix' -> Ptr Slice' -> Ptr MX' -> IO () casADi__MX__indexed_assignment''' :: MX -> IMatrix -> Slice -> MX -> IO () casADi__MX__indexed_assignment''' x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> c_CasADi__MX__indexed_assignment_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn -- classy wrapper mx_indexed_assignment''' :: MXClass a => a -> IMatrix -> Slice -> MX -> IO () mx_indexed_assignment''' x = casADi__MX__indexed_assignment''' (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__indexed_assignment_TIC_TIC_TIC_TIC" c_CasADi__MX__indexed_assignment_TIC_TIC_TIC_TIC :: Ptr MX' -> Ptr Slice' -> Ptr IMatrix' -> Ptr MX' -> IO () casADi__MX__indexed_assignment'''' :: MX -> Slice -> IMatrix -> MX -> IO () casADi__MX__indexed_assignment'''' x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> c_CasADi__MX__indexed_assignment_TIC_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn -- classy wrapper mx_indexed_assignment'''' :: MXClass a => a -> Slice -> IMatrix -> MX -> IO () mx_indexed_assignment'''' x = casADi__MX__indexed_assignment'''' (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__indexed_assignment_TIC_TIC_TIC_TIC_TIC" c_CasADi__MX__indexed_assignment_TIC_TIC_TIC_TIC_TIC :: Ptr MX' -> Ptr IMatrix' -> Ptr IndexList' -> Ptr MX' -> IO () casADi__MX__indexed_assignment''''' :: MX -> IMatrix -> IndexList -> MX -> IO () casADi__MX__indexed_assignment''''' x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> c_CasADi__MX__indexed_assignment_TIC_TIC_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn -- classy wrapper mx_indexed_assignment''''' :: MXClass a => a -> IMatrix -> IndexList -> MX -> IO () mx_indexed_assignment''''' x = casADi__MX__indexed_assignment''''' (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__MX__indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC :: Ptr MX' -> Ptr IndexList' -> Ptr IMatrix' -> Ptr MX' -> IO () casADi__MX__indexed_assignment'''''' :: MX -> IndexList -> IMatrix -> MX -> IO () casADi__MX__indexed_assignment'''''' x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> c_CasADi__MX__indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn -- classy wrapper mx_indexed_assignment'''''' :: MXClass a => a -> IndexList -> IMatrix -> MX -> IO () mx_indexed_assignment'''''' x = casADi__MX__indexed_assignment'''''' (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__MX__indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC :: Ptr MX' -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr MX' -> IO () casADi__MX__indexed_assignment''''''' :: MX -> IMatrix -> IMatrix -> MX -> IO () casADi__MX__indexed_assignment''''''' x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> c_CasADi__MX__indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn -- classy wrapper mx_indexed_assignment''''''' :: MXClass a => a -> IMatrix -> IMatrix -> MX -> IO () mx_indexed_assignment''''''' x = casADi__MX__indexed_assignment''''''' (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__indexed_one_based_assignment_TIC" c_CasADi__MX__indexed_one_based_assignment_TIC :: Ptr MX' -> CInt -> Ptr MX' -> IO () casADi__MX__indexed_one_based_assignment' :: MX -> Int -> MX -> IO () casADi__MX__indexed_one_based_assignment' x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__MX__indexed_one_based_assignment_TIC x0' x1' x2' >>= wrapReturn -- classy wrapper mx_indexed_one_based_assignment' :: MXClass a => a -> Int -> MX -> IO () mx_indexed_one_based_assignment' x = casADi__MX__indexed_one_based_assignment' (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__indexed_zero_based_assignment_TIC_TIC" c_CasADi__MX__indexed_zero_based_assignment_TIC_TIC :: Ptr MX' -> CInt -> Ptr MX' -> IO () casADi__MX__indexed_zero_based_assignment'' :: MX -> Int -> MX -> IO () casADi__MX__indexed_zero_based_assignment'' x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__MX__indexed_zero_based_assignment_TIC_TIC x0' x1' x2' >>= wrapReturn -- classy wrapper mx_indexed_zero_based_assignment'' :: MXClass a => a -> Int -> MX -> IO () mx_indexed_zero_based_assignment'' x = casADi__MX__indexed_zero_based_assignment'' (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__MX__indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC :: Ptr MX' -> Ptr IndexList' -> Ptr MX' -> IO () casADi__MX__indexed_assignment'''''''' :: MX -> IndexList -> MX -> IO () casADi__MX__indexed_assignment'''''''' x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__MX__indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' >>= wrapReturn -- classy wrapper mx_indexed_assignment'''''''' :: MXClass a => a -> IndexList -> MX -> IO () mx_indexed_assignment'''''''' x = casADi__MX__indexed_assignment'''''''' (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__MX__indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC :: Ptr MX' -> Ptr Slice' -> Ptr MX' -> IO () casADi__MX__indexed_assignment''''''''' :: MX -> Slice -> MX -> IO () casADi__MX__indexed_assignment''''''''' x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__MX__indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' >>= wrapReturn -- classy wrapper mx_indexed_assignment''''''''' :: MXClass a => a -> Slice -> MX -> IO () mx_indexed_assignment''''''''' x = casADi__MX__indexed_assignment''''''''' (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__sparsityRef" c_CasADi__MX__sparsityRef :: Ptr MX' -> IO (Ptr Sparsity') casADi__MX__sparsityRef :: MX -> IO Sparsity casADi__MX__sparsityRef x0 = withMarshal x0 $ \x0' -> c_CasADi__MX__sparsityRef x0' >>= wrapReturn -- classy wrapper {-| >Access the sparsity, make a copy if there are multiple references to it. -} mx_sparsityRef :: MXClass a => a -> IO Sparsity mx_sparsityRef x = casADi__MX__sparsityRef (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__erase" c_CasADi__MX__erase :: Ptr MX' -> Ptr (CppVec CInt) -> Ptr (CppVec CInt) -> IO () casADi__MX__erase :: MX -> Vector Int -> Vector Int -> IO () casADi__MX__erase x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__MX__erase x0' x1' x2' >>= wrapReturn -- classy wrapper {-| >Erase a submatrix. -} mx_erase :: MXClass a => a -> Vector Int -> Vector Int -> IO () mx_erase x = casADi__MX__erase (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__enlarge" c_CasADi__MX__enlarge :: Ptr MX' -> CInt -> CInt -> Ptr (CppVec CInt) -> Ptr (CppVec CInt) -> IO () casADi__MX__enlarge :: MX -> Int -> Int -> Vector Int -> Vector Int -> IO () casADi__MX__enlarge x0 x1 x2 x3 x4 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> withMarshal x4 $ \x4' -> c_CasADi__MX__enlarge x0' x1' x2' x3' x4' >>= wrapReturn -- classy wrapper {-| >Enlarge matrix Make the matrix larger by inserting empty rows and columns, >keeping the existing non-zeros. -} mx_enlarge :: MXClass a => a -> Int -> Int -> Vector Int -> Vector Int -> IO () mx_enlarge x = casADi__MX__enlarge (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__operator_minus" c_CasADi__MX__operator_minus :: Ptr MX' -> IO (Ptr MX') casADi__MX__operator_minus :: MX -> IO MX casADi__MX__operator_minus x0 = withMarshal x0 $ \x0' -> c_CasADi__MX__operator_minus x0' >>= wrapReturn -- 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__getDep" c_CasADi__MX__getDep :: Ptr MX' -> CInt -> IO (Ptr MX') casADi__MX__getDep :: MX -> Int -> IO MX casADi__MX__getDep x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__MX__getDep x0' x1' >>= wrapReturn -- classy wrapper {-| >Get the nth dependency as MX. -} mx_getDep :: MXClass a => a -> Int -> IO MX mx_getDep x = casADi__MX__getDep (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__getDep_TIC" c_CasADi__MX__getDep_TIC :: Ptr MX' -> IO (Ptr MX') casADi__MX__getDep' :: MX -> IO MX casADi__MX__getDep' x0 = withMarshal x0 $ \x0' -> c_CasADi__MX__getDep_TIC x0' >>= wrapReturn -- classy wrapper mx_getDep' :: MXClass a => a -> IO MX mx_getDep' x = casADi__MX__getDep' (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__getNumOutputs" c_CasADi__MX__getNumOutputs :: Ptr MX' -> IO CInt casADi__MX__getNumOutputs :: MX -> IO Int casADi__MX__getNumOutputs x0 = withMarshal x0 $ \x0' -> c_CasADi__MX__getNumOutputs x0' >>= wrapReturn -- classy wrapper {-| >Number of outputs. -} mx_getNumOutputs :: MXClass a => a -> IO Int mx_getNumOutputs x = casADi__MX__getNumOutputs (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__getOutput" c_CasADi__MX__getOutput :: Ptr MX' -> CInt -> IO (Ptr MX') casADi__MX__getOutput :: MX -> Int -> IO MX casADi__MX__getOutput x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__MX__getOutput x0' x1' >>= wrapReturn -- classy wrapper {-| >Get an output. -} mx_getOutput :: MXClass a => a -> Int -> IO MX mx_getOutput x = casADi__MX__getOutput (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__getOutput_TIC" c_CasADi__MX__getOutput_TIC :: Ptr MX' -> IO (Ptr MX') casADi__MX__getOutput' :: MX -> IO MX casADi__MX__getOutput' x0 = withMarshal x0 $ \x0' -> c_CasADi__MX__getOutput_TIC x0' >>= wrapReturn -- classy wrapper mx_getOutput' :: MXClass a => a -> IO MX mx_getOutput' x = casADi__MX__getOutput' (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__getNdeps" c_CasADi__MX__getNdeps :: Ptr MX' -> IO CInt casADi__MX__getNdeps :: MX -> IO Int casADi__MX__getNdeps x0 = withMarshal x0 $ \x0' -> c_CasADi__MX__getNdeps x0' >>= wrapReturn -- classy wrapper {-| >Get the number of dependencies of a binary SXElement. -} mx_getNdeps :: MXClass a => a -> IO Int mx_getNdeps x = casADi__MX__getNdeps (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__getName" c_CasADi__MX__getName :: Ptr MX' -> IO (Ptr StdString') casADi__MX__getName :: MX -> IO String casADi__MX__getName x0 = withMarshal x0 $ \x0' -> c_CasADi__MX__getName x0' >>= wrapReturn -- classy wrapper {-| >Get the name. -} mx_getName :: MXClass a => a -> IO String mx_getName x = casADi__MX__getName (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__getValue" c_CasADi__MX__getValue :: Ptr MX' -> IO CDouble casADi__MX__getValue :: MX -> IO Double casADi__MX__getValue x0 = withMarshal x0 $ \x0' -> c_CasADi__MX__getValue x0' >>= wrapReturn -- classy wrapper {-| >Get the value (only for scalar constant nodes) -} mx_getValue :: MXClass a => a -> IO Double mx_getValue x = casADi__MX__getValue (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__getMatrixValue" c_CasADi__MX__getMatrixValue :: Ptr MX' -> IO (Ptr DMatrix') casADi__MX__getMatrixValue :: MX -> IO DMatrix casADi__MX__getMatrixValue x0 = withMarshal x0 $ \x0' -> c_CasADi__MX__getMatrixValue x0' >>= wrapReturn -- classy wrapper {-| >Get the value (only for constant nodes) -} mx_getMatrixValue :: MXClass a => a -> IO DMatrix mx_getMatrixValue x = casADi__MX__getMatrixValue (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__isSymbolic" c_CasADi__MX__isSymbolic :: Ptr MX' -> IO CInt casADi__MX__isSymbolic :: MX -> IO Bool casADi__MX__isSymbolic x0 = withMarshal x0 $ \x0' -> c_CasADi__MX__isSymbolic x0' >>= wrapReturn -- classy wrapper {-| >Check if symbolic. -} mx_isSymbolic :: MXClass a => a -> IO Bool mx_isSymbolic x = casADi__MX__isSymbolic (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__isConstant" c_CasADi__MX__isConstant :: Ptr MX' -> IO CInt casADi__MX__isConstant :: MX -> IO Bool casADi__MX__isConstant x0 = withMarshal x0 $ \x0' -> c_CasADi__MX__isConstant x0' >>= wrapReturn -- classy wrapper {-| >Check if constant. -} 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 MX' -> IO CInt casADi__MX__isEvaluation :: MX -> IO Bool casADi__MX__isEvaluation x0 = withMarshal x0 $ \x0' -> c_CasADi__MX__isEvaluation x0' >>= wrapReturn -- classy wrapper {-| >Check if evaluation. -} 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 MX' -> IO CInt casADi__MX__isEvaluationOutput :: MX -> IO Bool casADi__MX__isEvaluationOutput x0 = withMarshal x0 $ \x0' -> c_CasADi__MX__isEvaluationOutput x0' >>= wrapReturn -- classy wrapper {-| >Check if evaluation output. -} mx_isEvaluationOutput :: MXClass a => a -> IO Bool mx_isEvaluationOutput x = casADi__MX__isEvaluationOutput (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__getEvaluationOutput" c_CasADi__MX__getEvaluationOutput :: Ptr MX' -> IO CInt casADi__MX__getEvaluationOutput :: MX -> IO Int casADi__MX__getEvaluationOutput x0 = withMarshal x0 $ \x0' -> c_CasADi__MX__getEvaluationOutput x0' >>= wrapReturn -- classy wrapper {-| >Get the index of evaluation output - only valid when isEvaluationoutput() is >true. -} mx_getEvaluationOutput :: MXClass a => a -> IO Int mx_getEvaluationOutput x = casADi__MX__getEvaluationOutput (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__isOperation" c_CasADi__MX__isOperation :: Ptr MX' -> CInt -> IO CInt casADi__MX__isOperation :: MX -> Int -> IO Bool casADi__MX__isOperation x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__MX__isOperation x0' x1' >>= wrapReturn -- classy wrapper {-| >Is it a certain operation. -} mx_isOperation :: MXClass a => a -> Int -> IO Bool mx_isOperation x = casADi__MX__isOperation (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__isMultiplication" c_CasADi__MX__isMultiplication :: Ptr MX' -> IO CInt casADi__MX__isMultiplication :: MX -> IO Bool casADi__MX__isMultiplication x0 = withMarshal x0 $ \x0' -> c_CasADi__MX__isMultiplication x0' >>= wrapReturn -- classy wrapper {-| >Check if multiplication. -} mx_isMultiplication :: MXClass a => a -> IO Bool mx_isMultiplication x = casADi__MX__isMultiplication (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__isCommutative" c_CasADi__MX__isCommutative :: Ptr MX' -> IO CInt casADi__MX__isCommutative :: MX -> IO Bool casADi__MX__isCommutative x0 = withMarshal x0 $ \x0' -> c_CasADi__MX__isCommutative x0' >>= wrapReturn -- classy wrapper {-| >Check if commutative operation. -} mx_isCommutative :: MXClass a => a -> IO Bool mx_isCommutative x = casADi__MX__isCommutative (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__isNorm" c_CasADi__MX__isNorm :: Ptr MX' -> IO CInt casADi__MX__isNorm :: MX -> IO Bool casADi__MX__isNorm x0 = withMarshal x0 $ \x0' -> c_CasADi__MX__isNorm x0' >>= wrapReturn -- classy wrapper {-| >Check if norm. -} mx_isNorm :: MXClass a => a -> IO Bool mx_isNorm x = casADi__MX__isNorm (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__isSymbolicSparse" c_CasADi__MX__isSymbolicSparse :: Ptr MX' -> IO CInt casADi__MX__isSymbolicSparse :: MX -> IO Bool casADi__MX__isSymbolicSparse x0 = withMarshal x0 $ \x0' -> c_CasADi__MX__isSymbolicSparse x0' >>= wrapReturn -- classy wrapper {-| >check if all nonzeros are symbolic (this function is currently identical to >isSymbolic) -} mx_isSymbolicSparse :: MXClass a => a -> IO Bool mx_isSymbolicSparse x = casADi__MX__isSymbolicSparse (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__isIdentity" c_CasADi__MX__isIdentity :: Ptr MX' -> IO CInt casADi__MX__isIdentity :: MX -> IO Bool casADi__MX__isIdentity x0 = withMarshal x0 $ \x0' -> c_CasADi__MX__isIdentity x0' >>= wrapReturn -- classy wrapper {-| >check if identity -} mx_isIdentity :: MXClass a => a -> IO Bool mx_isIdentity x = casADi__MX__isIdentity (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__isZero" c_CasADi__MX__isZero :: Ptr MX' -> IO CInt casADi__MX__isZero :: MX -> IO Bool casADi__MX__isZero x0 = withMarshal x0 $ \x0' -> c_CasADi__MX__isZero x0' >>= wrapReturn -- classy wrapper {-| >check if zero (note that false negative answers are possible) -} mx_isZero :: MXClass a => a -> IO Bool mx_isZero x = casADi__MX__isZero (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__isOne" c_CasADi__MX__isOne :: Ptr MX' -> IO CInt casADi__MX__isOne :: MX -> IO Bool casADi__MX__isOne x0 = withMarshal x0 $ \x0' -> c_CasADi__MX__isOne x0' >>= wrapReturn -- classy wrapper {-| >check if zero (note that false negative answers are possible) -} mx_isOne :: MXClass a => a -> IO Bool mx_isOne x = casADi__MX__isOne (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__isMinusOne" c_CasADi__MX__isMinusOne :: Ptr MX' -> IO CInt casADi__MX__isMinusOne :: MX -> IO Bool casADi__MX__isMinusOne x0 = withMarshal x0 $ \x0' -> c_CasADi__MX__isMinusOne x0' >>= wrapReturn -- classy wrapper {-| >check if zero (note that false negative answers are possible) -} mx_isMinusOne :: MXClass a => a -> IO Bool mx_isMinusOne x = casADi__MX__isMinusOne (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__isTranspose" c_CasADi__MX__isTranspose :: Ptr MX' -> IO CInt casADi__MX__isTranspose :: MX -> IO Bool casADi__MX__isTranspose x0 = withMarshal x0 $ \x0' -> c_CasADi__MX__isTranspose x0' >>= wrapReturn -- classy wrapper {-| >Is the expression a transpose? -} mx_isTranspose :: MXClass a => a -> IO Bool mx_isTranspose x = casADi__MX__isTranspose (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__isRegular" c_CasADi__MX__isRegular :: Ptr MX' -> IO CInt casADi__MX__isRegular :: MX -> IO Bool casADi__MX__isRegular x0 = withMarshal x0 $ \x0' -> c_CasADi__MX__isRegular x0' >>= wrapReturn -- classy wrapper {-| >Checks if expression does not contain NaN or Inf. -} mx_isRegular :: MXClass a => a -> IO Bool mx_isRegular x = casADi__MX__isRegular (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__getFunction" c_CasADi__MX__getFunction :: Ptr MX' -> IO (Ptr Function') casADi__MX__getFunction :: MX -> IO Function casADi__MX__getFunction x0 = withMarshal x0 $ \x0' -> c_CasADi__MX__getFunction x0' >>= wrapReturn -- classy wrapper {-| >Get function. -} mx_getFunction :: MXClass a => a -> IO Function mx_getFunction x = casADi__MX__getFunction (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__isBinary" c_CasADi__MX__isBinary :: Ptr MX' -> IO CInt casADi__MX__isBinary :: MX -> IO Bool casADi__MX__isBinary x0 = withMarshal x0 $ \x0' -> c_CasADi__MX__isBinary x0' >>= wrapReturn -- classy wrapper {-| >Is binary operation. -} mx_isBinary :: MXClass a => a -> IO Bool mx_isBinary x = casADi__MX__isBinary (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__isUnary" c_CasADi__MX__isUnary :: Ptr MX' -> IO CInt casADi__MX__isUnary :: MX -> IO Bool casADi__MX__isUnary x0 = withMarshal x0 $ \x0' -> c_CasADi__MX__isUnary x0' >>= wrapReturn -- classy wrapper {-| >Is unary operation. -} mx_isUnary :: MXClass a => a -> IO Bool mx_isUnary x = casADi__MX__isUnary (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__getOp" c_CasADi__MX__getOp :: Ptr MX' -> IO CInt casADi__MX__getOp :: MX -> IO Int casADi__MX__getOp x0 = withMarshal x0 $ \x0' -> c_CasADi__MX__getOp x0' >>= wrapReturn -- classy wrapper {-| >Get operation type. -} mx_getOp :: MXClass a => a -> IO Int mx_getOp x = casADi__MX__getOp (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__isEqual" c_CasADi__MX__isEqual :: Ptr MX' -> Ptr MX' -> CInt -> IO CInt casADi__MX__isEqual :: MX -> MX -> Int -> IO Bool casADi__MX__isEqual x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__MX__isEqual x0' x1' x2' >>= wrapReturn -- classy wrapper {-| >> bool CasADi::MX::isEqual(const MX &y, int depth=0) const >------------------------------------------------------------------------ > >Check if two nodes are equivalent up to a given depth. Depth=0 checks if the >expressions are identical, i.e. points to the same node. > >a = x*x b = x*x > >a.isEqual(b,0) will return false, but a.isEqual(b,1) will return true > >> bool CasADi::MX::isEqual(const MXNode *y, int depth=0) const >------------------------------------------------------------------------ >[INTERNAL] -} mx_isEqual :: MXClass a => a -> MX -> Int -> IO Bool mx_isEqual x = casADi__MX__isEqual (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__isEqual_TIC" c_CasADi__MX__isEqual_TIC :: Ptr MX' -> Ptr MX' -> IO CInt casADi__MX__isEqual' :: MX -> MX -> IO Bool casADi__MX__isEqual' x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__MX__isEqual_TIC x0' x1' >>= wrapReturn -- classy wrapper mx_isEqual' :: MXClass a => a -> MX -> IO Bool mx_isEqual' x = casADi__MX__isEqual' (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX____hash__" c_CasADi__MX____hash__ :: Ptr MX' -> IO CLong casADi__MX____hash__ :: MX -> IO Int casADi__MX____hash__ x0 = withMarshal x0 $ \x0' -> c_CasADi__MX____hash__ x0' >>= wrapReturn -- classy wrapper {-| >Returns a number that is unique for a given MXNode. If the MX does not point >to any node, 0 is returned. -} mx___hash__ :: MXClass a => a -> IO Int mx___hash__ x = casADi__MX____hash__ (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__getTemp" c_CasADi__MX__getTemp :: Ptr MX' -> IO CInt casADi__MX__getTemp :: MX -> IO Int casADi__MX__getTemp x0 = withMarshal x0 $ \x0' -> c_CasADi__MX__getTemp x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Get the temporary >variable -} mx_getTemp :: MXClass a => a -> IO Int mx_getTemp x = casADi__MX__getTemp (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__setTemp" c_CasADi__MX__setTemp :: Ptr MX' -> CInt -> IO () casADi__MX__setTemp :: MX -> Int -> IO () casADi__MX__setTemp x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__MX__setTemp x0' x1' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Set the temporary >variable. -} mx_setTemp :: MXClass a => a -> Int -> IO () mx_setTemp x = casADi__MX__setTemp (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__binary" c_CasADi__MX__binary :: 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' -> c_CasADi__MX__binary x0' x1' x2' >>= wrapReturn -- classy wrapper {-| >Create nodes by their ID. -} mx_binary :: Int -> MX -> MX -> IO MX mx_binary = casADi__MX__binary -- direct wrapper foreign import ccall unsafe "CasADi__MX__unary" c_CasADi__MX__unary :: CInt -> Ptr MX' -> IO (Ptr MX') casADi__MX__unary :: Int -> MX -> IO MX casADi__MX__unary x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__MX__unary x0' x1' >>= wrapReturn -- classy wrapper {-| >Create nodes by their ID. -} mx_unary :: Int -> MX -> IO MX mx_unary = casADi__MX__unary -- direct wrapper foreign import ccall unsafe "CasADi__MX__inf" c_CasADi__MX__inf :: Ptr Sparsity' -> IO (Ptr MX') casADi__MX__inf :: Sparsity -> IO MX casADi__MX__inf x0 = withMarshal x0 $ \x0' -> c_CasADi__MX__inf x0' >>= wrapReturn -- classy wrapper {-| >create a matrix with all inf -} mx_inf :: Sparsity -> IO MX mx_inf = casADi__MX__inf -- direct wrapper foreign import ccall unsafe "CasADi__MX__inf_TIC" c_CasADi__MX__inf_TIC :: CInt -> CInt -> IO (Ptr MX') casADi__MX__inf' :: Int -> Int -> IO MX casADi__MX__inf' x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__MX__inf_TIC x0' x1' >>= wrapReturn -- classy wrapper mx_inf' :: Int -> Int -> IO MX mx_inf' = casADi__MX__inf' -- direct wrapper foreign import ccall unsafe "CasADi__MX__inf_TIC_TIC" c_CasADi__MX__inf_TIC_TIC :: CInt -> IO (Ptr MX') casADi__MX__inf'' :: Int -> IO MX casADi__MX__inf'' x0 = withMarshal x0 $ \x0' -> c_CasADi__MX__inf_TIC_TIC x0' >>= wrapReturn -- classy wrapper mx_inf'' :: Int -> IO MX mx_inf'' = casADi__MX__inf'' -- direct wrapper foreign import ccall unsafe "CasADi__MX__inf_TIC_TIC_TIC" c_CasADi__MX__inf_TIC_TIC_TIC :: IO (Ptr MX') casADi__MX__inf''' :: IO MX casADi__MX__inf''' = c_CasADi__MX__inf_TIC_TIC_TIC >>= wrapReturn -- classy wrapper mx_inf''' :: IO MX mx_inf''' = casADi__MX__inf''' -- direct wrapper foreign import ccall unsafe "CasADi__MX__nan" c_CasADi__MX__nan :: Ptr Sparsity' -> IO (Ptr MX') casADi__MX__nan :: Sparsity -> IO MX casADi__MX__nan x0 = withMarshal x0 $ \x0' -> c_CasADi__MX__nan x0' >>= wrapReturn -- classy wrapper {-| >create a matrix with all nan -} mx_nan :: Sparsity -> IO MX mx_nan = casADi__MX__nan -- direct wrapper foreign import ccall unsafe "CasADi__MX__nan_TIC" c_CasADi__MX__nan_TIC :: CInt -> CInt -> IO (Ptr MX') casADi__MX__nan' :: Int -> Int -> IO MX casADi__MX__nan' x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__MX__nan_TIC x0' x1' >>= wrapReturn -- classy wrapper mx_nan' :: Int -> Int -> IO MX mx_nan' = casADi__MX__nan' -- direct wrapper foreign import ccall unsafe "CasADi__MX__nan_TIC_TIC" c_CasADi__MX__nan_TIC_TIC :: CInt -> IO (Ptr MX') casADi__MX__nan'' :: Int -> IO MX casADi__MX__nan'' x0 = withMarshal x0 $ \x0' -> c_CasADi__MX__nan_TIC_TIC x0' >>= wrapReturn -- classy wrapper mx_nan'' :: Int -> IO MX mx_nan'' = casADi__MX__nan'' -- direct wrapper foreign import ccall unsafe "CasADi__MX__nan_TIC_TIC_TIC" c_CasADi__MX__nan_TIC_TIC_TIC :: IO (Ptr MX') casADi__MX__nan''' :: IO MX casADi__MX__nan''' = c_CasADi__MX__nan_TIC_TIC_TIC >>= wrapReturn -- classy wrapper mx_nan''' :: IO MX mx_nan''' = casADi__MX__nan''' -- direct wrapper foreign import ccall unsafe "CasADi__MX__repmat" c_CasADi__MX__repmat :: Ptr MX' -> Ptr Sparsity' -> IO (Ptr MX') casADi__MX__repmat :: MX -> Sparsity -> IO MX casADi__MX__repmat x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__MX__repmat x0' x1' >>= wrapReturn -- classy wrapper {-| >create a matrix by repeating an existing matrix -} mx_repmat :: MX -> Sparsity -> IO MX mx_repmat = casADi__MX__repmat -- direct wrapper foreign import ccall unsafe "CasADi__MX__repmat_TIC" c_CasADi__MX__repmat_TIC :: Ptr MX' -> CInt -> CInt -> IO (Ptr MX') casADi__MX__repmat' :: MX -> Int -> Int -> IO MX casADi__MX__repmat' x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__MX__repmat_TIC x0' x1' x2' >>= wrapReturn -- classy wrapper mx_repmat' :: MX -> Int -> Int -> IO MX mx_repmat' = casADi__MX__repmat' -- direct wrapper foreign import ccall unsafe "CasADi__MX__repmat_TIC_TIC" c_CasADi__MX__repmat_TIC_TIC :: Ptr MX' -> CInt -> IO (Ptr MX') casADi__MX__repmat'' :: MX -> Int -> IO MX casADi__MX__repmat'' x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__MX__repmat_TIC_TIC x0' x1' >>= wrapReturn -- classy wrapper mx_repmat'' :: MX -> Int -> IO MX mx_repmat'' = casADi__MX__repmat'' -- direct wrapper foreign import ccall unsafe "CasADi__MX__eye" c_CasADi__MX__eye :: CInt -> IO (Ptr MX') casADi__MX__eye :: Int -> IO MX casADi__MX__eye x0 = withMarshal x0 $ \x0' -> c_CasADi__MX__eye x0' >>= wrapReturn -- classy wrapper mx_eye :: Int -> IO MX mx_eye = casADi__MX__eye -- direct wrapper foreign import ccall unsafe "CasADi__MX__setSub" c_CasADi__MX__setSub :: Ptr MX' -> Ptr MX' -> CInt -> CInt -> IO () casADi__MX__setSub :: MX -> MX -> Int -> Int -> IO () casADi__MX__setSub x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> c_CasADi__MX__setSub x0' x1' x2' x3' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] -} mx_setSub :: MXClass a => a -> MX -> Int -> Int -> IO () mx_setSub x = casADi__MX__setSub (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__setSub_TIC" c_CasADi__MX__setSub_TIC :: Ptr MX' -> Ptr MX' -> Ptr (CppVec CInt) -> CInt -> IO () casADi__MX__setSub' :: MX -> MX -> Vector Int -> Int -> IO () casADi__MX__setSub' x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> c_CasADi__MX__setSub_TIC x0' x1' x2' x3' >>= wrapReturn -- classy wrapper mx_setSub' :: MXClass a => a -> MX -> Vector Int -> Int -> IO () mx_setSub' x = casADi__MX__setSub' (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__setSub_TIC_TIC" c_CasADi__MX__setSub_TIC_TIC :: Ptr MX' -> Ptr MX' -> CInt -> Ptr (CppVec CInt) -> IO () casADi__MX__setSub'' :: MX -> MX -> Int -> Vector Int -> IO () casADi__MX__setSub'' x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> c_CasADi__MX__setSub_TIC_TIC x0' x1' x2' x3' >>= wrapReturn -- classy wrapper mx_setSub'' :: MXClass a => a -> MX -> Int -> Vector Int -> IO () mx_setSub'' x = casADi__MX__setSub'' (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__setSub_TIC_TIC_TIC" c_CasADi__MX__setSub_TIC_TIC_TIC :: Ptr MX' -> Ptr MX' -> Ptr (CppVec CInt) -> Ptr (CppVec CInt) -> IO () casADi__MX__setSub''' :: MX -> MX -> Vector Int -> Vector Int -> IO () casADi__MX__setSub''' x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> c_CasADi__MX__setSub_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn -- classy wrapper mx_setSub''' :: MXClass a => a -> MX -> Vector Int -> Vector Int -> IO () mx_setSub''' x = casADi__MX__setSub''' (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__setSub_TIC_TIC_TIC_TIC" c_CasADi__MX__setSub_TIC_TIC_TIC_TIC :: Ptr MX' -> Ptr MX' -> Ptr IMatrix' -> IO () casADi__MX__setSub'''' :: MX -> MX -> IMatrix -> IO () casADi__MX__setSub'''' x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__MX__setSub_TIC_TIC_TIC_TIC x0' x1' x2' >>= wrapReturn -- classy wrapper mx_setSub'''' :: MXClass a => a -> MX -> IMatrix -> IO () mx_setSub'''' x = casADi__MX__setSub'''' (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__setSub_TIC_TIC_TIC_TIC_TIC" c_CasADi__MX__setSub_TIC_TIC_TIC_TIC_TIC :: Ptr MX' -> Ptr MX' -> Ptr IMatrix' -> Ptr (CppVec CInt) -> IO () casADi__MX__setSub''''' :: MX -> MX -> IMatrix -> Vector Int -> IO () casADi__MX__setSub''''' x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> c_CasADi__MX__setSub_TIC_TIC_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn -- classy wrapper mx_setSub''''' :: MXClass a => a -> MX -> IMatrix -> Vector Int -> IO () mx_setSub''''' x = casADi__MX__setSub''''' (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__setSub_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__MX__setSub_TIC_TIC_TIC_TIC_TIC_TIC :: Ptr MX' -> Ptr MX' -> Ptr (CppVec CInt) -> Ptr IMatrix' -> IO () casADi__MX__setSub'''''' :: MX -> MX -> Vector Int -> IMatrix -> IO () casADi__MX__setSub'''''' x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> c_CasADi__MX__setSub_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn -- classy wrapper mx_setSub'''''' :: MXClass a => a -> MX -> Vector Int -> IMatrix -> IO () mx_setSub'''''' x = casADi__MX__setSub'''''' (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__MX__setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC :: Ptr MX' -> Ptr MX' -> Ptr Slice' -> Ptr Slice' -> IO () casADi__MX__setSub''''''' :: MX -> MX -> Slice -> Slice -> IO () casADi__MX__setSub''''''' x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> c_CasADi__MX__setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn -- classy wrapper mx_setSub''''''' :: MXClass a => a -> MX -> Slice -> Slice -> IO () mx_setSub''''''' x = casADi__MX__setSub''''''' (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__MX__setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC :: Ptr MX' -> Ptr MX' -> Ptr IMatrix' -> Ptr IMatrix' -> IO () casADi__MX__setSub'''''''' :: MX -> MX -> IMatrix -> IMatrix -> IO () casADi__MX__setSub'''''''' x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> c_CasADi__MX__setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn -- classy wrapper mx_setSub'''''''' :: MXClass a => a -> MX -> IMatrix -> IMatrix -> IO () mx_setSub'''''''' x = casADi__MX__setSub'''''''' (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__MX__setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC :: Ptr MX' -> Ptr MX' -> Ptr Sparsity' -> CInt -> IO () casADi__MX__setSub''''''''' :: MX -> MX -> Sparsity -> Int -> IO () casADi__MX__setSub''''''''' x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> c_CasADi__MX__setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn -- classy wrapper mx_setSub''''''''' :: MXClass a => a -> MX -> Sparsity -> Int -> IO () mx_setSub''''''''' x = casADi__MX__setSub''''''''' (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__getNZ" c_CasADi__MX__getNZ :: Ptr MX' -> CInt -> IO (Ptr MX') casADi__MX__getNZ :: MX -> Int -> IO MX casADi__MX__getNZ x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__MX__getNZ x0' x1' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] -} mx_getNZ :: MXClass a => a -> Int -> IO MX mx_getNZ x = casADi__MX__getNZ (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__getNZ_TIC" c_CasADi__MX__getNZ_TIC :: Ptr MX' -> Ptr (CppVec CInt) -> IO (Ptr MX') casADi__MX__getNZ' :: MX -> Vector Int -> IO MX casADi__MX__getNZ' x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__MX__getNZ_TIC x0' x1' >>= wrapReturn -- classy wrapper mx_getNZ' :: MXClass a => a -> Vector Int -> IO MX mx_getNZ' x = casADi__MX__getNZ' (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__getNZ_TIC_TIC" c_CasADi__MX__getNZ_TIC_TIC :: Ptr MX' -> Ptr Slice' -> IO (Ptr MX') casADi__MX__getNZ'' :: MX -> Slice -> IO MX casADi__MX__getNZ'' x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__MX__getNZ_TIC_TIC x0' x1' >>= wrapReturn -- classy wrapper mx_getNZ'' :: MXClass a => a -> Slice -> IO MX mx_getNZ'' x = casADi__MX__getNZ'' (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__getNZ_TIC_TIC_TIC" c_CasADi__MX__getNZ_TIC_TIC_TIC :: Ptr MX' -> Ptr IMatrix' -> IO (Ptr MX') casADi__MX__getNZ''' :: MX -> IMatrix -> IO MX casADi__MX__getNZ''' x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__MX__getNZ_TIC_TIC_TIC x0' x1' >>= wrapReturn -- classy wrapper mx_getNZ''' :: MXClass a => a -> IMatrix -> IO MX mx_getNZ''' x = casADi__MX__getNZ''' (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__setNZ" c_CasADi__MX__setNZ :: Ptr MX' -> CInt -> Ptr MX' -> IO () casADi__MX__setNZ :: MX -> Int -> MX -> IO () casADi__MX__setNZ x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__MX__setNZ x0' x1' x2' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] -} mx_setNZ :: MXClass a => a -> Int -> MX -> IO () mx_setNZ x = casADi__MX__setNZ (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__setNZ_TIC" c_CasADi__MX__setNZ_TIC :: Ptr MX' -> Ptr (CppVec CInt) -> Ptr MX' -> IO () casADi__MX__setNZ' :: MX -> Vector Int -> MX -> IO () casADi__MX__setNZ' x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__MX__setNZ_TIC x0' x1' x2' >>= wrapReturn -- classy wrapper mx_setNZ' :: MXClass a => a -> Vector Int -> MX -> IO () mx_setNZ' x = casADi__MX__setNZ' (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__setNZ_TIC_TIC" c_CasADi__MX__setNZ_TIC_TIC :: Ptr MX' -> Ptr Slice' -> Ptr MX' -> IO () casADi__MX__setNZ'' :: MX -> Slice -> MX -> IO () casADi__MX__setNZ'' x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__MX__setNZ_TIC_TIC x0' x1' x2' >>= wrapReturn -- classy wrapper mx_setNZ'' :: MXClass a => a -> Slice -> MX -> IO () mx_setNZ'' x = casADi__MX__setNZ'' (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__setNZ_TIC_TIC_TIC" c_CasADi__MX__setNZ_TIC_TIC_TIC :: Ptr MX' -> Ptr IMatrix' -> Ptr MX' -> IO () casADi__MX__setNZ''' :: MX -> IMatrix -> MX -> IO () casADi__MX__setNZ''' x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__MX__setNZ_TIC_TIC_TIC x0' x1' x2' >>= wrapReturn -- classy wrapper mx_setNZ''' :: MXClass a => a -> IMatrix -> MX -> IO () mx_setNZ''' x = casADi__MX__setNZ''' (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__append" c_CasADi__MX__append :: Ptr MX' -> Ptr MX' -> IO () casADi__MX__append :: MX -> MX -> IO () casADi__MX__append x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__MX__append x0' x1' >>= wrapReturn -- classy wrapper {-| >Append a matrix vertically (NOTE: only efficient if vector) -} 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 MX' -> Ptr MX' -> IO () casADi__MX__appendColumns :: MX -> MX -> IO () casADi__MX__appendColumns x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__MX__appendColumns x0' x1' >>= wrapReturn -- classy wrapper {-| >Append a matrix horizontally. -} mx_appendColumns :: MXClass a => a -> MX -> IO () mx_appendColumns x = casADi__MX__appendColumns (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX____add__" c_CasADi__MX____add__ :: Ptr MX' -> Ptr MX' -> IO (Ptr MX') casADi__MX____add__ :: MX -> MX -> IO MX casADi__MX____add__ x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__MX____add__ x0' x1' >>= wrapReturn -- classy wrapper mx___add__ :: MXClass a => a -> MX -> IO MX mx___add__ x = casADi__MX____add__ (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX____sub__" c_CasADi__MX____sub__ :: Ptr MX' -> Ptr MX' -> IO (Ptr MX') casADi__MX____sub__ :: MX -> MX -> IO MX casADi__MX____sub__ x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__MX____sub__ x0' x1' >>= wrapReturn -- classy wrapper mx___sub__ :: MXClass a => a -> MX -> IO MX mx___sub__ x = casADi__MX____sub__ (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX____mul__" c_CasADi__MX____mul__ :: Ptr MX' -> Ptr MX' -> IO (Ptr MX') casADi__MX____mul__ :: MX -> MX -> IO MX casADi__MX____mul__ x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__MX____mul__ x0' x1' >>= wrapReturn -- classy wrapper mx___mul__ :: MXClass a => a -> MX -> IO MX mx___mul__ x = casADi__MX____mul__ (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX____div__" c_CasADi__MX____div__ :: Ptr MX' -> Ptr MX' -> IO (Ptr MX') casADi__MX____div__ :: MX -> MX -> IO MX casADi__MX____div__ x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__MX____div__ x0' x1' >>= wrapReturn -- classy wrapper mx___div__ :: MXClass a => a -> MX -> IO MX mx___div__ x = casADi__MX____div__ (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX____lt__" c_CasADi__MX____lt__ :: Ptr MX' -> Ptr MX' -> IO (Ptr MX') casADi__MX____lt__ :: MX -> MX -> IO MX casADi__MX____lt__ x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__MX____lt__ x0' x1' >>= wrapReturn -- classy wrapper mx___lt__ :: MXClass a => a -> MX -> IO MX mx___lt__ x = casADi__MX____lt__ (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX____le__" c_CasADi__MX____le__ :: Ptr MX' -> Ptr MX' -> IO (Ptr MX') casADi__MX____le__ :: MX -> MX -> IO MX casADi__MX____le__ x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__MX____le__ x0' x1' >>= wrapReturn -- classy wrapper mx___le__ :: MXClass a => a -> MX -> IO MX mx___le__ x = casADi__MX____le__ (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX____eq__" c_CasADi__MX____eq__ :: Ptr MX' -> Ptr MX' -> IO (Ptr MX') casADi__MX____eq__ :: MX -> MX -> IO MX casADi__MX____eq__ x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__MX____eq__ x0' x1' >>= wrapReturn -- classy wrapper mx___eq__ :: MXClass a => a -> MX -> IO MX mx___eq__ x = casADi__MX____eq__ (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX____ne__" c_CasADi__MX____ne__ :: Ptr MX' -> Ptr MX' -> IO (Ptr MX') casADi__MX____ne__ :: MX -> MX -> IO MX casADi__MX____ne__ x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__MX____ne__ x0' x1' >>= wrapReturn -- classy wrapper mx___ne__ :: MXClass a => a -> MX -> IO MX mx___ne__ x = casADi__MX____ne__ (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX____truediv__" c_CasADi__MX____truediv__ :: Ptr MX' -> Ptr MX' -> IO (Ptr MX') casADi__MX____truediv__ :: MX -> MX -> IO MX casADi__MX____truediv__ x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__MX____truediv__ x0' x1' >>= wrapReturn -- classy wrapper mx___truediv__ :: MXClass a => a -> MX -> IO MX mx___truediv__ x = casADi__MX____truediv__ (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX____pow__" c_CasADi__MX____pow__ :: Ptr MX' -> Ptr MX' -> IO (Ptr MX') casADi__MX____pow__ :: MX -> MX -> IO MX casADi__MX____pow__ x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__MX____pow__ x0' x1' >>= wrapReturn -- classy wrapper mx___pow__ :: MXClass a => a -> MX -> IO MX mx___pow__ x = casADi__MX____pow__ (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX____constpow__" c_CasADi__MX____constpow__ :: Ptr MX' -> Ptr MX' -> IO (Ptr MX') casADi__MX____constpow__ :: MX -> MX -> IO MX casADi__MX____constpow__ x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__MX____constpow__ x0' x1' >>= wrapReturn -- classy wrapper mx___constpow__ :: MXClass a => a -> MX -> IO MX mx___constpow__ x = casADi__MX____constpow__ (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX____mrdivide__" c_CasADi__MX____mrdivide__ :: Ptr MX' -> Ptr MX' -> IO (Ptr MX') casADi__MX____mrdivide__ :: MX -> MX -> IO MX casADi__MX____mrdivide__ x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__MX____mrdivide__ x0' x1' >>= wrapReturn -- classy wrapper mx___mrdivide__ :: MXClass a => a -> MX -> IO MX mx___mrdivide__ x = casADi__MX____mrdivide__ (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX____mpower__" c_CasADi__MX____mpower__ :: Ptr MX' -> Ptr MX' -> IO (Ptr MX') casADi__MX____mpower__ :: MX -> MX -> IO MX casADi__MX____mpower__ x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__MX____mpower__ x0' x1' >>= wrapReturn -- classy wrapper mx___mpower__ :: MXClass a => a -> MX -> IO MX mx___mpower__ x = casADi__MX____mpower__ (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__mul" c_CasADi__MX__mul :: Ptr MX' -> Ptr MX' -> Ptr Sparsity' -> IO (Ptr MX') casADi__MX__mul :: MX -> MX -> Sparsity -> IO MX casADi__MX__mul x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__MX__mul x0' x1' x2' >>= wrapReturn -- classy wrapper mx_mul :: MXClass a => a -> MX -> Sparsity -> IO MX mx_mul x = casADi__MX__mul (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__mul_TIC" c_CasADi__MX__mul_TIC :: Ptr MX' -> Ptr MX' -> IO (Ptr MX') casADi__MX__mul' :: MX -> MX -> IO MX casADi__MX__mul' x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__MX__mul_TIC x0' x1' >>= wrapReturn -- classy wrapper mx_mul' :: MXClass a => a -> MX -> IO MX mx_mul' x = casADi__MX__mul' (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__mul_full" c_CasADi__MX__mul_full :: Ptr MX' -> Ptr MX' -> Ptr Sparsity' -> IO (Ptr MX') casADi__MX__mul_full :: MX -> MX -> Sparsity -> IO MX casADi__MX__mul_full x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__MX__mul_full x0' x1' x2' >>= wrapReturn -- classy wrapper mx_mul_full :: MXClass a => a -> MX -> Sparsity -> IO MX mx_mul_full x = casADi__MX__mul_full (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__mul_full_TIC" c_CasADi__MX__mul_full_TIC :: Ptr MX' -> Ptr MX' -> IO (Ptr MX') casADi__MX__mul_full' :: MX -> MX -> IO MX casADi__MX__mul_full' x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__MX__mul_full_TIC x0' x1' >>= wrapReturn -- classy wrapper mx_mul_full' :: MXClass a => a -> MX -> IO MX mx_mul_full' x = casADi__MX__mul_full' (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__inner_prod" c_CasADi__MX__inner_prod :: Ptr MX' -> Ptr MX' -> IO (Ptr MX') casADi__MX__inner_prod :: MX -> MX -> IO MX casADi__MX__inner_prod x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__MX__inner_prod x0' x1' >>= wrapReturn -- classy wrapper mx_inner_prod :: MXClass a => a -> MX -> IO MX mx_inner_prod x = casADi__MX__inner_prod (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__outer_prod" c_CasADi__MX__outer_prod :: Ptr MX' -> Ptr MX' -> IO (Ptr MX') casADi__MX__outer_prod :: MX -> MX -> IO MX casADi__MX__outer_prod x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__MX__outer_prod x0' x1' >>= wrapReturn -- classy wrapper mx_outer_prod :: MXClass a => a -> MX -> IO MX mx_outer_prod x = casADi__MX__outer_prod (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__constpow" c_CasADi__MX__constpow :: Ptr MX' -> Ptr MX' -> IO (Ptr MX') casADi__MX__constpow :: MX -> MX -> IO MX casADi__MX__constpow x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__MX__constpow x0' x1' >>= wrapReturn -- classy wrapper mx_constpow :: MXClass a => a -> MX -> IO MX mx_constpow x = casADi__MX__constpow (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__fmin" c_CasADi__MX__fmin :: Ptr MX' -> Ptr MX' -> IO (Ptr MX') casADi__MX__fmin :: MX -> MX -> IO MX casADi__MX__fmin x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__MX__fmin x0' x1' >>= wrapReturn -- classy wrapper mx_fmin :: MXClass a => a -> MX -> IO MX mx_fmin x = casADi__MX__fmin (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__fmax" c_CasADi__MX__fmax :: Ptr MX' -> Ptr MX' -> IO (Ptr MX') casADi__MX__fmax :: MX -> MX -> IO MX casADi__MX__fmax x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__MX__fmax x0' x1' >>= wrapReturn -- classy wrapper mx_fmax :: MXClass a => a -> MX -> IO MX mx_fmax x = casADi__MX__fmax (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__printme" c_CasADi__MX__printme :: 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' -> c_CasADi__MX__printme x0' x1' >>= wrapReturn -- 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__arctan2" c_CasADi__MX__arctan2 :: Ptr MX' -> Ptr MX' -> IO (Ptr MX') casADi__MX__arctan2 :: MX -> MX -> IO MX casADi__MX__arctan2 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__MX__arctan2 x0' x1' >>= wrapReturn -- classy wrapper mx_arctan2 :: MXClass a => a -> MX -> IO MX mx_arctan2 x = casADi__MX__arctan2 (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__logic_and" c_CasADi__MX__logic_and :: Ptr MX' -> Ptr MX' -> IO (Ptr MX') casADi__MX__logic_and :: MX -> MX -> IO MX casADi__MX__logic_and x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__MX__logic_and x0' x1' >>= wrapReturn -- classy wrapper mx_logic_and :: MXClass a => a -> MX -> IO MX mx_logic_and x = casADi__MX__logic_and (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__logic_or" c_CasADi__MX__logic_or :: Ptr MX' -> Ptr MX' -> IO (Ptr MX') casADi__MX__logic_or :: MX -> MX -> IO MX casADi__MX__logic_or x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__MX__logic_or x0' x1' >>= wrapReturn -- classy wrapper mx_logic_or :: MXClass a => a -> MX -> IO MX mx_logic_or x = casADi__MX__logic_or (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__if_else_zero" c_CasADi__MX__if_else_zero :: Ptr MX' -> Ptr MX' -> IO (Ptr MX') casADi__MX__if_else_zero :: MX -> MX -> IO MX casADi__MX__if_else_zero x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__MX__if_else_zero x0' x1' >>= wrapReturn -- classy wrapper mx_if_else_zero :: MXClass a => a -> MX -> IO MX mx_if_else_zero x = casADi__MX__if_else_zero (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX____copysign__" c_CasADi__MX____copysign__ :: Ptr MX' -> Ptr MX' -> IO (Ptr MX') casADi__MX____copysign__ :: MX -> MX -> IO MX casADi__MX____copysign__ x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__MX____copysign__ x0' x1' >>= wrapReturn -- classy wrapper mx___copysign__ :: MXClass a => a -> MX -> IO MX mx___copysign__ x = casADi__MX____copysign__ (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__exp" c_CasADi__MX__exp :: Ptr MX' -> IO (Ptr MX') casADi__MX__exp :: MX -> IO MX casADi__MX__exp x0 = withMarshal x0 $ \x0' -> c_CasADi__MX__exp x0' >>= wrapReturn -- classy wrapper mx_exp :: MXClass a => a -> IO MX mx_exp x = casADi__MX__exp (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__log" c_CasADi__MX__log :: Ptr MX' -> IO (Ptr MX') casADi__MX__log :: MX -> IO MX casADi__MX__log x0 = withMarshal x0 $ \x0' -> c_CasADi__MX__log x0' >>= wrapReturn -- classy wrapper mx_log :: MXClass a => a -> IO MX mx_log x = casADi__MX__log (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__log10" c_CasADi__MX__log10 :: Ptr MX' -> IO (Ptr MX') casADi__MX__log10 :: MX -> IO MX casADi__MX__log10 x0 = withMarshal x0 $ \x0' -> c_CasADi__MX__log10 x0' >>= wrapReturn -- classy wrapper mx_log10 :: MXClass a => a -> IO MX mx_log10 x = casADi__MX__log10 (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__sqrt" c_CasADi__MX__sqrt :: Ptr MX' -> IO (Ptr MX') casADi__MX__sqrt :: MX -> IO MX casADi__MX__sqrt x0 = withMarshal x0 $ \x0' -> c_CasADi__MX__sqrt x0' >>= wrapReturn -- classy wrapper mx_sqrt :: MXClass a => a -> IO MX mx_sqrt x = casADi__MX__sqrt (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__sin" c_CasADi__MX__sin :: Ptr MX' -> IO (Ptr MX') casADi__MX__sin :: MX -> IO MX casADi__MX__sin x0 = withMarshal x0 $ \x0' -> c_CasADi__MX__sin x0' >>= wrapReturn -- classy wrapper mx_sin :: MXClass a => a -> IO MX mx_sin x = casADi__MX__sin (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__cos" c_CasADi__MX__cos :: Ptr MX' -> IO (Ptr MX') casADi__MX__cos :: MX -> IO MX casADi__MX__cos x0 = withMarshal x0 $ \x0' -> c_CasADi__MX__cos x0' >>= wrapReturn -- classy wrapper mx_cos :: MXClass a => a -> IO MX mx_cos x = casADi__MX__cos (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__tan" c_CasADi__MX__tan :: Ptr MX' -> IO (Ptr MX') casADi__MX__tan :: MX -> IO MX casADi__MX__tan x0 = withMarshal x0 $ \x0' -> c_CasADi__MX__tan x0' >>= wrapReturn -- classy wrapper mx_tan :: MXClass a => a -> IO MX mx_tan x = casADi__MX__tan (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__arcsin" c_CasADi__MX__arcsin :: Ptr MX' -> IO (Ptr MX') casADi__MX__arcsin :: MX -> IO MX casADi__MX__arcsin x0 = withMarshal x0 $ \x0' -> c_CasADi__MX__arcsin x0' >>= wrapReturn -- classy wrapper mx_arcsin :: MXClass a => a -> IO MX mx_arcsin x = casADi__MX__arcsin (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__arccos" c_CasADi__MX__arccos :: Ptr MX' -> IO (Ptr MX') casADi__MX__arccos :: MX -> IO MX casADi__MX__arccos x0 = withMarshal x0 $ \x0' -> c_CasADi__MX__arccos x0' >>= wrapReturn -- classy wrapper mx_arccos :: MXClass a => a -> IO MX mx_arccos x = casADi__MX__arccos (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__arctan" c_CasADi__MX__arctan :: Ptr MX' -> IO (Ptr MX') casADi__MX__arctan :: MX -> IO MX casADi__MX__arctan x0 = withMarshal x0 $ \x0' -> c_CasADi__MX__arctan x0' >>= wrapReturn -- classy wrapper mx_arctan :: MXClass a => a -> IO MX mx_arctan x = casADi__MX__arctan (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__floor" c_CasADi__MX__floor :: Ptr MX' -> IO (Ptr MX') casADi__MX__floor :: MX -> IO MX casADi__MX__floor x0 = withMarshal x0 $ \x0' -> c_CasADi__MX__floor x0' >>= wrapReturn -- classy wrapper mx_floor :: MXClass a => a -> IO MX mx_floor x = casADi__MX__floor (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__ceil" c_CasADi__MX__ceil :: Ptr MX' -> IO (Ptr MX') casADi__MX__ceil :: MX -> IO MX casADi__MX__ceil x0 = withMarshal x0 $ \x0' -> c_CasADi__MX__ceil x0' >>= wrapReturn -- classy wrapper mx_ceil :: MXClass a => a -> IO MX mx_ceil x = casADi__MX__ceil (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__fabs" c_CasADi__MX__fabs :: Ptr MX' -> IO (Ptr MX') casADi__MX__fabs :: MX -> IO MX casADi__MX__fabs x0 = withMarshal x0 $ \x0' -> c_CasADi__MX__fabs x0' >>= wrapReturn -- classy wrapper mx_fabs :: MXClass a => a -> IO MX mx_fabs x = casADi__MX__fabs (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__sign" c_CasADi__MX__sign :: Ptr MX' -> IO (Ptr MX') casADi__MX__sign :: MX -> IO MX casADi__MX__sign x0 = withMarshal x0 $ \x0' -> c_CasADi__MX__sign x0' >>= wrapReturn -- classy wrapper mx_sign :: MXClass a => a -> IO MX mx_sign x = casADi__MX__sign (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__erfinv" c_CasADi__MX__erfinv :: Ptr MX' -> IO (Ptr MX') casADi__MX__erfinv :: MX -> IO MX casADi__MX__erfinv x0 = withMarshal x0 $ \x0' -> c_CasADi__MX__erfinv x0' >>= wrapReturn -- classy wrapper mx_erfinv :: MXClass a => a -> IO MX mx_erfinv x = casADi__MX__erfinv (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__erf" c_CasADi__MX__erf :: Ptr MX' -> IO (Ptr MX') casADi__MX__erf :: MX -> IO MX casADi__MX__erf x0 = withMarshal x0 $ \x0' -> c_CasADi__MX__erf x0' >>= wrapReturn -- classy wrapper mx_erf :: MXClass a => a -> IO MX mx_erf x = casADi__MX__erf (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__sinh" c_CasADi__MX__sinh :: Ptr MX' -> IO (Ptr MX') casADi__MX__sinh :: MX -> IO MX casADi__MX__sinh x0 = withMarshal x0 $ \x0' -> c_CasADi__MX__sinh x0' >>= wrapReturn -- classy wrapper mx_sinh :: MXClass a => a -> IO MX mx_sinh x = casADi__MX__sinh (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__cosh" c_CasADi__MX__cosh :: Ptr MX' -> IO (Ptr MX') casADi__MX__cosh :: MX -> IO MX casADi__MX__cosh x0 = withMarshal x0 $ \x0' -> c_CasADi__MX__cosh x0' >>= wrapReturn -- classy wrapper mx_cosh :: MXClass a => a -> IO MX mx_cosh x = casADi__MX__cosh (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__tanh" c_CasADi__MX__tanh :: Ptr MX' -> IO (Ptr MX') casADi__MX__tanh :: MX -> IO MX casADi__MX__tanh x0 = withMarshal x0 $ \x0' -> c_CasADi__MX__tanh x0' >>= wrapReturn -- classy wrapper mx_tanh :: MXClass a => a -> IO MX mx_tanh x = casADi__MX__tanh (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__arcsinh" c_CasADi__MX__arcsinh :: Ptr MX' -> IO (Ptr MX') casADi__MX__arcsinh :: MX -> IO MX casADi__MX__arcsinh x0 = withMarshal x0 $ \x0' -> c_CasADi__MX__arcsinh x0' >>= wrapReturn -- classy wrapper mx_arcsinh :: MXClass a => a -> IO MX mx_arcsinh x = casADi__MX__arcsinh (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__arccosh" c_CasADi__MX__arccosh :: Ptr MX' -> IO (Ptr MX') casADi__MX__arccosh :: MX -> IO MX casADi__MX__arccosh x0 = withMarshal x0 $ \x0' -> c_CasADi__MX__arccosh x0' >>= wrapReturn -- classy wrapper mx_arccosh :: MXClass a => a -> IO MX mx_arccosh x = casADi__MX__arccosh (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__arctanh" c_CasADi__MX__arctanh :: Ptr MX' -> IO (Ptr MX') casADi__MX__arctanh :: MX -> IO MX casADi__MX__arctanh x0 = withMarshal x0 $ \x0' -> c_CasADi__MX__arctanh x0' >>= wrapReturn -- classy wrapper mx_arctanh :: MXClass a => a -> IO MX mx_arctanh x = casADi__MX__arctanh (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__logic_not" c_CasADi__MX__logic_not :: Ptr MX' -> IO (Ptr MX') casADi__MX__logic_not :: MX -> IO MX casADi__MX__logic_not x0 = withMarshal x0 $ \x0' -> c_CasADi__MX__logic_not x0' >>= wrapReturn -- classy wrapper mx_logic_not :: MXClass a => a -> IO MX mx_logic_not x = casADi__MX__logic_not (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__attachAssert" c_CasADi__MX__attachAssert :: Ptr MX' -> Ptr MX' -> Ptr StdString' -> IO (Ptr MX') casADi__MX__attachAssert :: MX -> MX -> String -> IO MX casADi__MX__attachAssert x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__MX__attachAssert x0' x1' x2' >>= wrapReturn -- classy wrapper {-| >returns itself, but with an assertion attached > >If y does not evaluate to 1, a runtime error is raised -} mx_attachAssert :: MXClass a => a -> MX -> String -> IO MX mx_attachAssert x = casADi__MX__attachAssert (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__attachAssert_TIC" c_CasADi__MX__attachAssert_TIC :: Ptr MX' -> Ptr MX' -> IO (Ptr MX') casADi__MX__attachAssert' :: MX -> MX -> IO MX casADi__MX__attachAssert' x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__MX__attachAssert_TIC x0' x1' >>= wrapReturn -- classy wrapper mx_attachAssert' :: MXClass a => a -> MX -> IO MX mx_attachAssert' x = casADi__MX__attachAssert' (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__setSparse" c_CasADi__MX__setSparse :: Ptr MX' -> Ptr Sparsity' -> CInt -> IO (Ptr MX') casADi__MX__setSparse :: MX -> Sparsity -> Bool -> IO MX casADi__MX__setSparse x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__MX__setSparse x0' x1' x2' >>= wrapReturn -- classy wrapper {-| >Set sparse. -} mx_setSparse :: MXClass a => a -> Sparsity -> Bool -> IO MX mx_setSparse x = casADi__MX__setSparse (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__setSparse_TIC" c_CasADi__MX__setSparse_TIC :: Ptr MX' -> Ptr Sparsity' -> IO (Ptr MX') casADi__MX__setSparse' :: MX -> Sparsity -> IO MX casADi__MX__setSparse' x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__MX__setSparse_TIC x0' x1' >>= wrapReturn -- classy wrapper mx_setSparse' :: MXClass a => a -> Sparsity -> IO MX mx_setSparse' x = casADi__MX__setSparse' (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__densify" c_CasADi__MX__densify :: Ptr MX' -> Ptr MX' -> IO () casADi__MX__densify :: MX -> MX -> IO () casADi__MX__densify x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__MX__densify x0' x1' >>= wrapReturn -- classy wrapper {-| >Make the matrix dense. -} mx_densify :: MXClass a => a -> MX -> IO () mx_densify x = casADi__MX__densify (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__densify_TIC" c_CasADi__MX__densify_TIC :: Ptr MX' -> IO () casADi__MX__densify' :: MX -> IO () casADi__MX__densify' x0 = withMarshal x0 $ \x0' -> c_CasADi__MX__densify_TIC x0' >>= wrapReturn -- classy wrapper mx_densify' :: MXClass a => a -> IO () mx_densify' x = casADi__MX__densify' (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__lift" c_CasADi__MX__lift :: Ptr MX' -> Ptr MX' -> IO () casADi__MX__lift :: MX -> MX -> IO () casADi__MX__lift x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__MX__lift x0' x1' >>= wrapReturn -- classy wrapper {-| >Lift an expression. -} mx_lift :: MXClass a => a -> MX -> IO () mx_lift x = casADi__MX__lift (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__addToSum" c_CasADi__MX__addToSum :: Ptr MX' -> Ptr MX' -> IO () casADi__MX__addToSum :: MX -> MX -> IO () casADi__MX__addToSum x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__MX__addToSum x0' x1' >>= wrapReturn -- classy wrapper {-| >Add an expression to the expression if the expression is non-empty, >otherwise assign. -} mx_addToSum :: MXClass a => a -> MX -> IO () mx_addToSum x = casADi__MX__addToSum (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__trans" c_CasADi__MX__trans :: Ptr MX' -> IO (Ptr MX') casADi__MX__trans :: MX -> IO MX casADi__MX__trans x0 = withMarshal x0 $ \x0' -> c_CasADi__MX__trans x0' >>= wrapReturn -- classy wrapper {-| >Transpose the matrix. -} mx_trans :: MXClass a => a -> IO MX mx_trans x = casADi__MX__trans (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__mapping" c_CasADi__MX__mapping :: Ptr MX' -> IO (Ptr IMatrix') casADi__MX__mapping :: MX -> IO IMatrix casADi__MX__mapping x0 = withMarshal x0 $ \x0' -> c_CasADi__MX__mapping x0' >>= wrapReturn -- classy wrapper {-| >Get an IMatrix representation of a GetNonzeros or SetNonzeros node. -} mx_mapping :: MXClass a => a -> IO IMatrix mx_mapping x = casADi__MX__mapping (castMX x) -- direct wrapper foreign import ccall unsafe "CasADi__MX__setMaxNumCallsInPrint" c_CasADi__MX__setMaxNumCallsInPrint :: CLong -> IO () casADi__MX__setMaxNumCallsInPrint :: Int -> IO () casADi__MX__setMaxNumCallsInPrint x0 = withMarshal x0 $ \x0' -> c_CasADi__MX__setMaxNumCallsInPrint x0' >>= wrapReturn -- classy wrapper mx_setMaxNumCallsInPrint :: Int -> IO () mx_setMaxNumCallsInPrint = casADi__MX__setMaxNumCallsInPrint -- direct wrapper foreign import ccall unsafe "CasADi__MX__setMaxNumCallsInPrint_TIC" c_CasADi__MX__setMaxNumCallsInPrint_TIC :: IO () casADi__MX__setMaxNumCallsInPrint' :: IO () casADi__MX__setMaxNumCallsInPrint' = c_CasADi__MX__setMaxNumCallsInPrint_TIC >>= wrapReturn -- classy wrapper mx_setMaxNumCallsInPrint' :: IO () mx_setMaxNumCallsInPrint' = casADi__MX__setMaxNumCallsInPrint' -- direct wrapper foreign import ccall unsafe "CasADi__MX__getMaxNumCallsInPrint" c_CasADi__MX__getMaxNumCallsInPrint :: IO CLong casADi__MX__getMaxNumCallsInPrint :: IO Int casADi__MX__getMaxNumCallsInPrint = c_CasADi__MX__getMaxNumCallsInPrint >>= wrapReturn -- classy wrapper mx_getMaxNumCallsInPrint :: IO Int mx_getMaxNumCallsInPrint = casADi__MX__getMaxNumCallsInPrint -- direct wrapper foreign import ccall unsafe "CasADi__MX__setEqualityCheckingDepth" c_CasADi__MX__setEqualityCheckingDepth :: CInt -> IO () casADi__MX__setEqualityCheckingDepth :: Int -> IO () casADi__MX__setEqualityCheckingDepth x0 = withMarshal x0 $ \x0' -> c_CasADi__MX__setEqualityCheckingDepth x0' >>= wrapReturn -- classy wrapper mx_setEqualityCheckingDepth :: Int -> IO () mx_setEqualityCheckingDepth = casADi__MX__setEqualityCheckingDepth -- direct wrapper foreign import ccall unsafe "CasADi__MX__setEqualityCheckingDepth_TIC" c_CasADi__MX__setEqualityCheckingDepth_TIC :: IO () casADi__MX__setEqualityCheckingDepth' :: IO () casADi__MX__setEqualityCheckingDepth' = c_CasADi__MX__setEqualityCheckingDepth_TIC >>= wrapReturn -- classy wrapper mx_setEqualityCheckingDepth' :: IO () mx_setEqualityCheckingDepth' = casADi__MX__setEqualityCheckingDepth' -- direct wrapper foreign import ccall unsafe "CasADi__MX__getEqualityCheckingDepth" c_CasADi__MX__getEqualityCheckingDepth :: IO CInt casADi__MX__getEqualityCheckingDepth :: IO Int casADi__MX__getEqualityCheckingDepth = c_CasADi__MX__getEqualityCheckingDepth >>= wrapReturn -- classy wrapper mx_getEqualityCheckingDepth :: IO Int mx_getEqualityCheckingDepth = casADi__MX__getEqualityCheckingDepth -- direct wrapper foreign import ccall unsafe "CasADi__MX__MX" c_CasADi__MX__MX :: IO (Ptr MX') casADi__MX__MX :: IO MX casADi__MX__MX = c_CasADi__MX__MX >>= wrapReturn -- classy wrapper {-| >> CasADi::MX::MX(const std::string &name, int nrow=1, int ncol=1) > >> CasADi::MX::MX(const std::string &name, const std::pair< int, int > &rc) > >> CasADi::MX::MX(const std::string &name, const Sparsity &sp) > >> CasADi::MX::MX(int nrow, int ncol) > >> CasADi::MX::MX(int nrow, int ncol, const MX &val) >------------------------------------------------------------------------ > >[DEPRECATED] > >> CasADi::MX::MX(const Sparsity &sp, int val=0) > >> CasADi::MX::MX(const Sparsity &sp, double val) > >> CasADi::MX::MX(const Sparsity &sp, const MX &val) >------------------------------------------------------------------------ > >Construct constant matrix with a given sparsity. > >> CasADi::MX::MX() >------------------------------------------------------------------------ > >Default constructor. > >> CasADi::MX::MX(double x) >------------------------------------------------------------------------ > >Create scalar constant (also implicit type conversion) > >> CasADi::MX::MX(const MX &x) >------------------------------------------------------------------------ > >Copy constructor. > >> CasADi::MX::MX(const std::vector< double > &x) >------------------------------------------------------------------------ > >Create vector constant (also implicit type conversion) > >> CasADi::MX::MX(const Matrix< double > &x) >------------------------------------------------------------------------ > >Create sparse matrix constant (also implicit type conversion) -} mx :: IO MX mx = casADi__MX__MX -- direct wrapper foreign import ccall unsafe "CasADi__MX__MX_TIC" c_CasADi__MX__MX_TIC :: Ptr Sparsity' -> CInt -> IO (Ptr MX') casADi__MX__MX' :: Sparsity -> Int -> IO MX casADi__MX__MX' x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__MX__MX_TIC x0' x1' >>= wrapReturn -- classy wrapper mx' :: Sparsity -> Int -> IO MX mx' = casADi__MX__MX' -- direct wrapper foreign import ccall unsafe "CasADi__MX__MX_TIC_TIC" c_CasADi__MX__MX_TIC_TIC :: Ptr Sparsity' -> IO (Ptr MX') casADi__MX__MX'' :: Sparsity -> IO MX casADi__MX__MX'' x0 = withMarshal x0 $ \x0' -> c_CasADi__MX__MX_TIC_TIC x0' >>= wrapReturn -- classy wrapper mx'' :: Sparsity -> IO MX mx'' = casADi__MX__MX'' -- direct wrapper foreign import ccall unsafe "CasADi__MX__MX_TIC_TIC_TIC" c_CasADi__MX__MX_TIC_TIC_TIC :: Ptr Sparsity' -> CDouble -> IO (Ptr MX') casADi__MX__MX''' :: Sparsity -> Double -> IO MX casADi__MX__MX''' x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__MX__MX_TIC_TIC_TIC x0' x1' >>= wrapReturn -- classy wrapper mx''' :: Sparsity -> Double -> IO MX mx''' = casADi__MX__MX''' -- direct wrapper foreign import ccall unsafe "CasADi__MX__MX_TIC_TIC_TIC_TIC" c_CasADi__MX__MX_TIC_TIC_TIC_TIC :: Ptr Sparsity' -> Ptr MX' -> IO (Ptr MX') casADi__MX__MX'''' :: Sparsity -> MX -> IO MX casADi__MX__MX'''' x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__MX__MX_TIC_TIC_TIC_TIC x0' x1' >>= wrapReturn -- classy wrapper mx'''' :: Sparsity -> MX -> IO MX mx'''' = casADi__MX__MX'''' -- direct wrapper foreign import ccall unsafe "CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC" c_CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC :: CDouble -> IO (Ptr MX') casADi__MX__MX''''' :: Double -> IO MX casADi__MX__MX''''' x0 = withMarshal x0 $ \x0' -> c_CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC x0' >>= wrapReturn -- classy wrapper mx''''' :: Double -> IO MX mx''''' = casADi__MX__MX''''' -- direct wrapper foreign import ccall unsafe "CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC_TIC :: Ptr MX' -> IO (Ptr MX') casADi__MX__MX'''''' :: MX -> IO MX casADi__MX__MX'''''' x0 = withMarshal x0 $ \x0' -> c_CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC_TIC x0' >>= wrapReturn -- classy wrapper mx'''''' :: MX -> IO MX mx'''''' = casADi__MX__MX'''''' -- direct wrapper foreign import ccall unsafe "CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC_TIC_TIC :: Ptr (CppVec CDouble) -> IO (Ptr MX') casADi__MX__MX''''''' :: Vector Double -> IO MX casADi__MX__MX''''''' x0 = withMarshal x0 $ \x0' -> c_CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' >>= wrapReturn -- classy wrapper mx''''''' :: Vector Double -> IO MX mx''''''' = casADi__MX__MX''''''' -- direct wrapper foreign import ccall unsafe "CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC :: Ptr DMatrix' -> IO (Ptr MX') casADi__MX__MX'''''''' :: DMatrix -> IO MX casADi__MX__MX'''''''' x0 = withMarshal x0 $ \x0' -> c_CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' >>= wrapReturn -- classy wrapper mx'''''''' :: DMatrix -> IO MX mx'''''''' = casADi__MX__MX''''''''