{-# OPTIONS_GHC -Wall #-} {-# OPTIONS_GHC -fno-warn-unused-imports #-} {-# OPTIONS_GHC -fno-warn-orphans #-} {-# Language ForeignFunctionInterface #-} {-# Language FlexibleInstances #-} {-# Language MultiParamTypeClasses #-} module Casadi.Wrappers.Classes.IMatrix ( IMatrix, IMatrixClass(..), imatrix, imatrix', imatrix'', imatrix''', imatrix'''', imatrix''''', imatrix'''''', imatrix''''''', imatrix'''''''', imatrix___add__, imatrix___constpow__, imatrix___copysign__, imatrix___div__, imatrix___eq__, imatrix___le__, imatrix___lt__, imatrix___mpower__, imatrix___mrdivide__, imatrix___mul__, imatrix___ne__, imatrix___nonzero__, imatrix___pow__, imatrix___sub__, imatrix___truediv__, imatrix_append, imatrix_appendColumns, imatrix_arccos, imatrix_arccosh, imatrix_arcsin, imatrix_arcsinh, imatrix_arctan, imatrix_arctan2, imatrix_arctanh, imatrix_at, imatrix_binary, imatrix_ceil, imatrix_className, imatrix_clear, imatrix_colind, imatrix_cos, imatrix_cosh, imatrix_data, imatrix_densify, imatrix_densify', imatrix_elem, imatrix_elem', imatrix_enlarge, imatrix_erase, imatrix_erf, imatrix_erfinv, imatrix_exp, imatrix_eye, imatrix_fabs, imatrix_floor, imatrix_fmax, imatrix_fmin, imatrix_get, imatrix_get', imatrix_get'', imatrix_get''', imatrix_get'''', imatrix_get''''', imatrix_getEqualityCheckingDepth, imatrix_getMaxNumCallsInPrint, imatrix_getName, imatrix_getValue, imatrix_hasNZ, imatrix_hasNonStructuralZeros, imatrix_if_else_zero, imatrix_indexed_assignment, imatrix_indexed_assignment', imatrix_indexed_assignment'', imatrix_indexed_assignment''', imatrix_indexed_assignment'''', imatrix_indexed_assignment''''', imatrix_indexed_assignment'''''', imatrix_indexed_assignment''''''', imatrix_indexed_assignment'''''''', imatrix_indexed_assignment''''''''', imatrix_indexed_one_based_assignment, imatrix_indexed_one_based_assignment', imatrix_indexed_one_based_assignment'', imatrix_indexed_zero_based_assignment, imatrix_indexed_zero_based_assignment', imatrix_indexed_zero_based_assignment'', imatrix_inf, imatrix_inf', imatrix_inf'', imatrix_inf''', imatrix_isConstant, imatrix_isEqual, imatrix_isIdentity, imatrix_isInteger, imatrix_isMinusOne, imatrix_isOne, imatrix_isRegular, imatrix_isSmooth, imatrix_isSymbolic, imatrix_isSymbolicSparse, imatrix_isZero, imatrix_log, imatrix_log10, imatrix_logic_and, imatrix_logic_not, imatrix_logic_or, imatrix_matrix_matrix, imatrix_matrix_scalar, imatrix_mul, imatrix_mul', imatrix_mul_full, imatrix_mul_full', imatrix_mul_no_alloc_nn, imatrix_mul_no_alloc_nn', imatrix_mul_no_alloc_nt, imatrix_mul_no_alloc_tn, imatrix_mul_no_alloc_tn', imatrix_nan, imatrix_nan', imatrix_nan'', imatrix_nan''', imatrix_nz_indexed_assignment, imatrix_nz_indexed_assignment', imatrix_nz_indexed_one_based_assignment, imatrix_nz_indexed_one_based_assignment', imatrix_nz_indexed_zero_based_assignment, imatrix_nz_indexed_zero_based_assignment', imatrix_operator_minus, imatrix_operator_plus, imatrix_printDense', imatrix_printScalar', imatrix_printSparse', imatrix_printVector', imatrix_printme, imatrix_quad_form, imatrix_remove, imatrix_repmat, imatrix_repmat', imatrix_repmat'', imatrix_repmat''', imatrix_reserve, imatrix_reserve', imatrix_resize, imatrix_row, imatrix_sanityCheck, imatrix_sanityCheck', imatrix_scalar_matrix, imatrix_set, imatrix_set', imatrix_set'', imatrix_set''', imatrix_set'''', imatrix_set''''', imatrix_setAll, imatrix_setEqualityCheckingDepth, imatrix_setEqualityCheckingDepth', imatrix_setMaxNumCallsInPrint, imatrix_setMaxNumCallsInPrint', imatrix_setNZ, imatrix_setNZ', imatrix_setNZ'', imatrix_setNZ''', imatrix_setPrecision, imatrix_setScientific, imatrix_setSparse, imatrix_setSparse', imatrix_setSub, imatrix_setSub', imatrix_setSub'', imatrix_setSub''', imatrix_setSub'''', imatrix_setSub''''', imatrix_setSub'''''', imatrix_setSub''''''', imatrix_setSub'''''''', imatrix_setSub''''''''', imatrix_setSub'''''''''', imatrix_setSub''''''''''', imatrix_setSub'''''''''''', imatrix_setSub''''''''''''', imatrix_setWidth, imatrix_setZero, imatrix_sign, imatrix_sin, imatrix_sinh, imatrix_sparsify, imatrix_sparsify', imatrix_sparsityRef, imatrix_sqrt, imatrix_tan, imatrix_tanh, imatrix_trans, imatrix_triplet, imatrix_triplet', imatrix_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 IMatrix where show = unsafePerformIO . printableObject_getDescription -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___sanityCheck" c_CasADi__Matrix_int___sanityCheck :: Ptr IMatrix' -> CInt -> IO () casADi__Matrix_int___sanityCheck :: IMatrix -> Bool -> IO () casADi__Matrix_int___sanityCheck x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_int___sanityCheck x0' x1' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Check if the >dimensions and colind,row vectors are compatible. > >Parameters: >----------- > >complete: set to true to also check elementwise throws an error as possible >result -} imatrix_sanityCheck :: IMatrixClass a => a -> Bool -> IO () imatrix_sanityCheck x = casADi__Matrix_int___sanityCheck (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___sanityCheck_TIC" c_CasADi__Matrix_int___sanityCheck_TIC :: Ptr IMatrix' -> IO () casADi__Matrix_int___sanityCheck' :: IMatrix -> IO () casADi__Matrix_int___sanityCheck' x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_int___sanityCheck_TIC x0' >>= wrapReturn -- classy wrapper imatrix_sanityCheck' :: IMatrixClass a => a -> IO () imatrix_sanityCheck' x = casADi__Matrix_int___sanityCheck' (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___at" c_CasADi__Matrix_int___at :: Ptr IMatrix' -> CInt -> IO CInt casADi__Matrix_int___at :: IMatrix -> Int -> IO Int casADi__Matrix_int___at x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_int___at x0' x1' >>= wrapReturn -- classy wrapper {-| >> const DataType& CasADi::Matrix< T >::at(int k) const >------------------------------------------------------------------------ >[INTERNAL] >Get a non-zero element. > >> DataType& CasADi::Matrix< T >::at(int k) >------------------------------------------------------------------------ >[INTERNAL] >Access a non-zero element. -} imatrix_at :: IMatrixClass a => a -> Int -> IO Int imatrix_at x = casADi__Matrix_int___at (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___elem" c_CasADi__Matrix_int___elem :: Ptr IMatrix' -> CInt -> CInt -> IO CInt casADi__Matrix_int___elem :: IMatrix -> Int -> Int -> IO Int casADi__Matrix_int___elem x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_int___elem x0' x1' x2' >>= wrapReturn -- classy wrapper {-| >> const DataType & CasADi::Matrix< DataType >::elem(int rr, int cc=0) const >------------------------------------------------------------------------ >[INTERNAL] >get an element > >> DataType & CasADi::Matrix< DataType >::elem(int rr, int cc=0) >------------------------------------------------------------------------ >[INTERNAL] >get a reference to an element -} imatrix_elem :: IMatrixClass a => a -> Int -> Int -> IO Int imatrix_elem x = casADi__Matrix_int___elem (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___elem_TIC" c_CasADi__Matrix_int___elem_TIC :: Ptr IMatrix' -> CInt -> IO CInt casADi__Matrix_int___elem' :: IMatrix -> Int -> IO Int casADi__Matrix_int___elem' x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_int___elem_TIC x0' x1' >>= wrapReturn -- classy wrapper imatrix_elem' :: IMatrixClass a => a -> Int -> IO Int imatrix_elem' x = casADi__Matrix_int___elem' (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___hasNZ" c_CasADi__Matrix_int___hasNZ :: Ptr IMatrix' -> CInt -> CInt -> IO CInt casADi__Matrix_int___hasNZ :: IMatrix -> Int -> Int -> IO Bool casADi__Matrix_int___hasNZ x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_int___hasNZ x0' x1' x2' >>= wrapReturn -- classy wrapper {-| >Returns true if the matrix has a non-zero at location rr,cc. -} imatrix_hasNZ :: IMatrixClass a => a -> Int -> Int -> IO Bool imatrix_hasNZ x = casADi__Matrix_int___hasNZ (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int_____nonzero__" c_CasADi__Matrix_int_____nonzero__ :: Ptr IMatrix' -> IO CInt casADi__Matrix_int_____nonzero__ :: IMatrix -> IO Bool casADi__Matrix_int_____nonzero__ x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_int_____nonzero__ x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Returns the >truth value of a Matrix. -} imatrix___nonzero__ :: IMatrixClass a => a -> IO Bool imatrix___nonzero__ x = casADi__Matrix_int_____nonzero__ (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___setSub" c_CasADi__Matrix_int___setSub :: Ptr IMatrix' -> Ptr IMatrix' -> CInt -> CInt -> IO () casADi__Matrix_int___setSub :: IMatrix -> IMatrix -> Int -> Int -> IO () casADi__Matrix_int___setSub x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> c_CasADi__Matrix_int___setSub x0' x1' x2' x3' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Set a submatrix. -} imatrix_setSub :: IMatrixClass a => a -> IMatrix -> Int -> Int -> IO () imatrix_setSub x = casADi__Matrix_int___setSub (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___setSub_TIC" c_CasADi__Matrix_int___setSub_TIC :: Ptr IMatrix' -> Ptr IMatrix' -> Ptr (CppVec CInt) -> CInt -> IO () casADi__Matrix_int___setSub' :: IMatrix -> IMatrix -> Vector Int -> Int -> IO () casADi__Matrix_int___setSub' x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> c_CasADi__Matrix_int___setSub_TIC x0' x1' x2' x3' >>= wrapReturn -- classy wrapper imatrix_setSub' :: IMatrixClass a => a -> IMatrix -> Vector Int -> Int -> IO () imatrix_setSub' x = casADi__Matrix_int___setSub' (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___setSub_TIC_TIC" c_CasADi__Matrix_int___setSub_TIC_TIC :: Ptr IMatrix' -> Ptr IMatrix' -> CInt -> Ptr (CppVec CInt) -> IO () casADi__Matrix_int___setSub'' :: IMatrix -> IMatrix -> Int -> Vector Int -> IO () casADi__Matrix_int___setSub'' x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> c_CasADi__Matrix_int___setSub_TIC_TIC x0' x1' x2' x3' >>= wrapReturn -- classy wrapper imatrix_setSub'' :: IMatrixClass a => a -> IMatrix -> Int -> Vector Int -> IO () imatrix_setSub'' x = casADi__Matrix_int___setSub'' (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___setSub_TIC_TIC_TIC" c_CasADi__Matrix_int___setSub_TIC_TIC_TIC :: Ptr IMatrix' -> Ptr IMatrix' -> Ptr (CppVec CInt) -> Ptr (CppVec CInt) -> IO () casADi__Matrix_int___setSub''' :: IMatrix -> IMatrix -> Vector Int -> Vector Int -> IO () casADi__Matrix_int___setSub''' x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> c_CasADi__Matrix_int___setSub_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn -- classy wrapper imatrix_setSub''' :: IMatrixClass a => a -> IMatrix -> Vector Int -> Vector Int -> IO () imatrix_setSub''' x = casADi__Matrix_int___setSub''' (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___setSub_TIC_TIC_TIC_TIC" c_CasADi__Matrix_int___setSub_TIC_TIC_TIC_TIC :: Ptr IMatrix' -> Ptr IMatrix' -> Ptr Slice' -> Ptr (CppVec CInt) -> IO () casADi__Matrix_int___setSub'''' :: IMatrix -> IMatrix -> Slice -> Vector Int -> IO () casADi__Matrix_int___setSub'''' x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> c_CasADi__Matrix_int___setSub_TIC_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn -- classy wrapper imatrix_setSub'''' :: IMatrixClass a => a -> IMatrix -> Slice -> Vector Int -> IO () imatrix_setSub'''' x = casADi__Matrix_int___setSub'''' (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___setSub_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_int___setSub_TIC_TIC_TIC_TIC_TIC :: Ptr IMatrix' -> Ptr IMatrix' -> Ptr (CppVec CInt) -> Ptr Slice' -> IO () casADi__Matrix_int___setSub''''' :: IMatrix -> IMatrix -> Vector Int -> Slice -> IO () casADi__Matrix_int___setSub''''' x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> c_CasADi__Matrix_int___setSub_TIC_TIC_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn -- classy wrapper imatrix_setSub''''' :: IMatrixClass a => a -> IMatrix -> Vector Int -> Slice -> IO () imatrix_setSub''''' x = casADi__Matrix_int___setSub''''' (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___setSub_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_int___setSub_TIC_TIC_TIC_TIC_TIC_TIC :: Ptr IMatrix' -> Ptr IMatrix' -> Ptr Slice' -> Ptr Slice' -> IO () casADi__Matrix_int___setSub'''''' :: IMatrix -> IMatrix -> Slice -> Slice -> IO () casADi__Matrix_int___setSub'''''' x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> c_CasADi__Matrix_int___setSub_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn -- classy wrapper imatrix_setSub'''''' :: IMatrixClass a => a -> IMatrix -> Slice -> Slice -> IO () imatrix_setSub'''''' x = casADi__Matrix_int___setSub'''''' (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_int___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC :: Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr (CppVec CInt) -> IO () casADi__Matrix_int___setSub''''''' :: IMatrix -> IMatrix -> IMatrix -> Vector Int -> IO () casADi__Matrix_int___setSub''''''' x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> c_CasADi__Matrix_int___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn -- classy wrapper imatrix_setSub''''''' :: IMatrixClass a => a -> IMatrix -> IMatrix -> Vector Int -> IO () imatrix_setSub''''''' x = casADi__Matrix_int___setSub''''''' (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_int___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC :: Ptr IMatrix' -> Ptr IMatrix' -> Ptr (CppVec CInt) -> Ptr IMatrix' -> IO () casADi__Matrix_int___setSub'''''''' :: IMatrix -> IMatrix -> Vector Int -> IMatrix -> IO () casADi__Matrix_int___setSub'''''''' x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> c_CasADi__Matrix_int___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn -- classy wrapper imatrix_setSub'''''''' :: IMatrixClass a => a -> IMatrix -> Vector Int -> IMatrix -> IO () imatrix_setSub'''''''' x = casADi__Matrix_int___setSub'''''''' (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_int___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC :: Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr Slice' -> IO () casADi__Matrix_int___setSub''''''''' :: IMatrix -> IMatrix -> IMatrix -> Slice -> IO () casADi__Matrix_int___setSub''''''''' x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> c_CasADi__Matrix_int___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn -- classy wrapper imatrix_setSub''''''''' :: IMatrixClass a => a -> IMatrix -> IMatrix -> Slice -> IO () imatrix_setSub''''''''' x = casADi__Matrix_int___setSub''''''''' (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_int___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC :: Ptr IMatrix' -> Ptr IMatrix' -> Ptr Slice' -> Ptr IMatrix' -> IO () casADi__Matrix_int___setSub'''''''''' :: IMatrix -> IMatrix -> Slice -> IMatrix -> IO () casADi__Matrix_int___setSub'''''''''' x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> c_CasADi__Matrix_int___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn -- classy wrapper imatrix_setSub'''''''''' :: IMatrixClass a => a -> IMatrix -> Slice -> IMatrix -> IO () imatrix_setSub'''''''''' x = casADi__Matrix_int___setSub'''''''''' (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_int___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC :: Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> IO () casADi__Matrix_int___setSub''''''''''' :: IMatrix -> IMatrix -> IMatrix -> IMatrix -> IO () casADi__Matrix_int___setSub''''''''''' x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> c_CasADi__Matrix_int___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn -- classy wrapper imatrix_setSub''''''''''' :: IMatrixClass a => a -> IMatrix -> IMatrix -> IMatrix -> IO () imatrix_setSub''''''''''' x = casADi__Matrix_int___setSub''''''''''' (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_int___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC :: Ptr IMatrix' -> Ptr IMatrix' -> Ptr Slice' -> CInt -> IO () casADi__Matrix_int___setSub'''''''''''' :: IMatrix -> IMatrix -> Slice -> Int -> IO () casADi__Matrix_int___setSub'''''''''''' x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> c_CasADi__Matrix_int___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn -- classy wrapper imatrix_setSub'''''''''''' :: IMatrixClass a => a -> IMatrix -> Slice -> Int -> IO () imatrix_setSub'''''''''''' x = casADi__Matrix_int___setSub'''''''''''' (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_int___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC :: Ptr IMatrix' -> Ptr IMatrix' -> Ptr Sparsity' -> CInt -> IO () casADi__Matrix_int___setSub''''''''''''' :: IMatrix -> IMatrix -> Sparsity -> Int -> IO () casADi__Matrix_int___setSub''''''''''''' x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> c_CasADi__Matrix_int___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn -- classy wrapper imatrix_setSub''''''''''''' :: IMatrixClass a => a -> IMatrix -> Sparsity -> Int -> IO () imatrix_setSub''''''''''''' x = casADi__Matrix_int___setSub''''''''''''' (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___setNZ" c_CasADi__Matrix_int___setNZ :: Ptr IMatrix' -> CInt -> Ptr IMatrix' -> IO () casADi__Matrix_int___setNZ :: IMatrix -> Int -> IMatrix -> IO () casADi__Matrix_int___setNZ x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_int___setNZ x0' x1' x2' >>= wrapReturn -- classy wrapper {-| >> void CasADi::Matrix< DataType >::setNZ(int k, const Matrix< DataType > &m) > >> void CasADi::Matrix< DataType >::setNZ(const std::vector< int > &k, const Matrix< DataType > &m) > >> void CasADi::Matrix< DataType >::setNZ(const Matrix< int > &k, const Matrix< DataType > &m) >------------------------------------------------------------------------ >[INTERNAL] >Set a set of nonzeros. > >> void CasADi::Matrix< T >::setNZ(const Slice &k, const Matrix< DataType > &m) >------------------------------------------------------------------------ > >Set a set of nonzeros. -} imatrix_setNZ :: IMatrixClass a => a -> Int -> IMatrix -> IO () imatrix_setNZ x = casADi__Matrix_int___setNZ (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___setNZ_TIC" c_CasADi__Matrix_int___setNZ_TIC :: Ptr IMatrix' -> Ptr (CppVec CInt) -> Ptr IMatrix' -> IO () casADi__Matrix_int___setNZ' :: IMatrix -> Vector Int -> IMatrix -> IO () casADi__Matrix_int___setNZ' x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_int___setNZ_TIC x0' x1' x2' >>= wrapReturn -- classy wrapper imatrix_setNZ' :: IMatrixClass a => a -> Vector Int -> IMatrix -> IO () imatrix_setNZ' x = casADi__Matrix_int___setNZ' (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___setNZ_TIC_TIC" c_CasADi__Matrix_int___setNZ_TIC_TIC :: Ptr IMatrix' -> Ptr Slice' -> Ptr IMatrix' -> IO () casADi__Matrix_int___setNZ'' :: IMatrix -> Slice -> IMatrix -> IO () casADi__Matrix_int___setNZ'' x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_int___setNZ_TIC_TIC x0' x1' x2' >>= wrapReturn -- classy wrapper imatrix_setNZ'' :: IMatrixClass a => a -> Slice -> IMatrix -> IO () imatrix_setNZ'' x = casADi__Matrix_int___setNZ'' (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___setNZ_TIC_TIC_TIC" c_CasADi__Matrix_int___setNZ_TIC_TIC_TIC :: Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> IO () casADi__Matrix_int___setNZ''' :: IMatrix -> IMatrix -> IMatrix -> IO () casADi__Matrix_int___setNZ''' x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_int___setNZ_TIC_TIC_TIC x0' x1' x2' >>= wrapReturn -- classy wrapper imatrix_setNZ''' :: IMatrixClass a => a -> IMatrix -> IMatrix -> IO () imatrix_setNZ''' x = casADi__Matrix_int___setNZ''' (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___append" c_CasADi__Matrix_int___append :: Ptr IMatrix' -> Ptr IMatrix' -> IO () casADi__Matrix_int___append :: IMatrix -> IMatrix -> IO () casADi__Matrix_int___append x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_int___append x0' x1' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Append a matrix >vertically (NOTE: only efficient if vector) -} imatrix_append :: IMatrixClass a => a -> IMatrix -> IO () imatrix_append x = casADi__Matrix_int___append (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___appendColumns" c_CasADi__Matrix_int___appendColumns :: Ptr IMatrix' -> Ptr IMatrix' -> IO () casADi__Matrix_int___appendColumns :: IMatrix -> IMatrix -> IO () casADi__Matrix_int___appendColumns x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_int___appendColumns x0' x1' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Append a >matrix horizontally. -} imatrix_appendColumns :: IMatrixClass a => a -> IMatrix -> IO () imatrix_appendColumns x = casADi__Matrix_int___appendColumns (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___nz_indexed_one_based_assignment" c_CasADi__Matrix_int___nz_indexed_one_based_assignment :: Ptr IMatrix' -> CInt -> CInt -> IO () casADi__Matrix_int___nz_indexed_one_based_assignment :: IMatrix -> Int -> Int -> IO () casADi__Matrix_int___nz_indexed_one_based_assignment x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_int___nz_indexed_one_based_assignment x0' x1' x2' >>= wrapReturn -- classy wrapper {-| >> void CasADi::Matrix< T >::nz_indexed_one_based_assignment(int k, const DataType &m) >------------------------------------------------------------------------ >[INTERNAL] >set a non-zero > >> void CasADi::Matrix< T >::nz_indexed_one_based_assignment(const Matrix< int > &k, const Matrix< DataType > &m) >------------------------------------------------------------------------ >[INTERNAL] >Indexing for interfaced languages get a non-zero -} imatrix_nz_indexed_one_based_assignment :: IMatrixClass a => a -> Int -> Int -> IO () imatrix_nz_indexed_one_based_assignment x = casADi__Matrix_int___nz_indexed_one_based_assignment (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___nz_indexed_zero_based_assignment" c_CasADi__Matrix_int___nz_indexed_zero_based_assignment :: Ptr IMatrix' -> CInt -> CInt -> IO () casADi__Matrix_int___nz_indexed_zero_based_assignment :: IMatrix -> Int -> Int -> IO () casADi__Matrix_int___nz_indexed_zero_based_assignment x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_int___nz_indexed_zero_based_assignment x0' x1' x2' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Indexing for interfaced languages get a non-zero -} imatrix_nz_indexed_zero_based_assignment :: IMatrixClass a => a -> Int -> Int -> IO () imatrix_nz_indexed_zero_based_assignment x = casADi__Matrix_int___nz_indexed_zero_based_assignment (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___nz_indexed_assignment" c_CasADi__Matrix_int___nz_indexed_assignment :: Ptr IMatrix' -> Ptr Slice' -> Ptr IMatrix' -> IO () casADi__Matrix_int___nz_indexed_assignment :: IMatrix -> Slice -> IMatrix -> IO () casADi__Matrix_int___nz_indexed_assignment x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_int___nz_indexed_assignment x0' x1' x2' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] >Indexing for interfaced languages get a non-zero -} imatrix_nz_indexed_assignment :: IMatrixClass a => a -> Slice -> IMatrix -> IO () imatrix_nz_indexed_assignment x = casADi__Matrix_int___nz_indexed_assignment (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___indexed_one_based_assignment" c_CasADi__Matrix_int___indexed_one_based_assignment :: Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> IO () casADi__Matrix_int___indexed_one_based_assignment :: IMatrix -> IMatrix -> IMatrix -> IO () casADi__Matrix_int___indexed_one_based_assignment x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_int___indexed_one_based_assignment x0' x1' x2' >>= wrapReturn -- classy wrapper {-| >> void CasADi::Matrix< T >::indexed_one_based_assignment(const Matrix< int > &k, const Matrix< DataType > &m) >------------------------------------------------------------------------ >[INTERNAL] >Indexing for interfaced languages get a non-zero > >> void CasADi::Matrix< T >::indexed_one_based_assignment(int rr, int cc, const DataType &m) >------------------------------------------------------------------------ >[INTERNAL] >set a matrix element > >> void CasADi::Matrix< T >::indexed_one_based_assignment(int rr, const DataType &m) >------------------------------------------------------------------------ >[INTERNAL] >set a vector element -} imatrix_indexed_one_based_assignment :: IMatrixClass a => a -> IMatrix -> IMatrix -> IO () imatrix_indexed_one_based_assignment x = casADi__Matrix_int___indexed_one_based_assignment (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___indexed_zero_based_assignment" c_CasADi__Matrix_int___indexed_zero_based_assignment :: Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> IO () casADi__Matrix_int___indexed_zero_based_assignment :: IMatrix -> IMatrix -> IMatrix -> IO () casADi__Matrix_int___indexed_zero_based_assignment x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_int___indexed_zero_based_assignment x0' x1' x2' >>= wrapReturn -- classy wrapper {-| >> void CasADi::Matrix< T >::indexed_zero_based_assignment(const Matrix< int > &k, const Matrix< DataType > &m) > >> void CasADi::Matrix< T >::indexed_zero_based_assignment(int rr, int cc, const DataType &m) >------------------------------------------------------------------------ >[INTERNAL] >Indexing for interfaced languages get a non-zero > >> void CasADi::Matrix< T >::indexed_zero_based_assignment(int rr, const DataType &m) >------------------------------------------------------------------------ >[INTERNAL] -} imatrix_indexed_zero_based_assignment :: IMatrixClass a => a -> IMatrix -> IMatrix -> IO () imatrix_indexed_zero_based_assignment x = casADi__Matrix_int___indexed_zero_based_assignment (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___nz_indexed_one_based_assignment_TIC" c_CasADi__Matrix_int___nz_indexed_one_based_assignment_TIC :: Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> IO () casADi__Matrix_int___nz_indexed_one_based_assignment' :: IMatrix -> IMatrix -> IMatrix -> IO () casADi__Matrix_int___nz_indexed_one_based_assignment' x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_int___nz_indexed_one_based_assignment_TIC x0' x1' x2' >>= wrapReturn -- classy wrapper imatrix_nz_indexed_one_based_assignment' :: IMatrixClass a => a -> IMatrix -> IMatrix -> IO () imatrix_nz_indexed_one_based_assignment' x = casADi__Matrix_int___nz_indexed_one_based_assignment' (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___nz_indexed_zero_based_assignment_TIC" c_CasADi__Matrix_int___nz_indexed_zero_based_assignment_TIC :: Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> IO () casADi__Matrix_int___nz_indexed_zero_based_assignment' :: IMatrix -> IMatrix -> IMatrix -> IO () casADi__Matrix_int___nz_indexed_zero_based_assignment' x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_int___nz_indexed_zero_based_assignment_TIC x0' x1' x2' >>= wrapReturn -- classy wrapper imatrix_nz_indexed_zero_based_assignment' :: IMatrixClass a => a -> IMatrix -> IMatrix -> IO () imatrix_nz_indexed_zero_based_assignment' x = casADi__Matrix_int___nz_indexed_zero_based_assignment' (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___nz_indexed_assignment_TIC" c_CasADi__Matrix_int___nz_indexed_assignment_TIC :: Ptr IMatrix' -> Ptr IndexList' -> Ptr IMatrix' -> IO () casADi__Matrix_int___nz_indexed_assignment' :: IMatrix -> IndexList -> IMatrix -> IO () casADi__Matrix_int___nz_indexed_assignment' x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_int___nz_indexed_assignment_TIC x0' x1' x2' >>= wrapReturn -- classy wrapper imatrix_nz_indexed_assignment' :: IMatrixClass a => a -> IndexList -> IMatrix -> IO () imatrix_nz_indexed_assignment' x = casADi__Matrix_int___nz_indexed_assignment' (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___indexed_one_based_assignment_TIC" c_CasADi__Matrix_int___indexed_one_based_assignment_TIC :: Ptr IMatrix' -> CInt -> CInt -> CInt -> IO () casADi__Matrix_int___indexed_one_based_assignment' :: IMatrix -> Int -> Int -> Int -> IO () casADi__Matrix_int___indexed_one_based_assignment' x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> c_CasADi__Matrix_int___indexed_one_based_assignment_TIC x0' x1' x2' x3' >>= wrapReturn -- classy wrapper imatrix_indexed_one_based_assignment' :: IMatrixClass a => a -> Int -> Int -> Int -> IO () imatrix_indexed_one_based_assignment' x = casADi__Matrix_int___indexed_one_based_assignment' (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___indexed_zero_based_assignment_TIC" c_CasADi__Matrix_int___indexed_zero_based_assignment_TIC :: Ptr IMatrix' -> CInt -> CInt -> CInt -> IO () casADi__Matrix_int___indexed_zero_based_assignment' :: IMatrix -> Int -> Int -> Int -> IO () casADi__Matrix_int___indexed_zero_based_assignment' x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> c_CasADi__Matrix_int___indexed_zero_based_assignment_TIC x0' x1' x2' x3' >>= wrapReturn -- classy wrapper imatrix_indexed_zero_based_assignment' :: IMatrixClass a => a -> Int -> Int -> Int -> IO () imatrix_indexed_zero_based_assignment' x = casADi__Matrix_int___indexed_zero_based_assignment' (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___indexed_assignment" c_CasADi__Matrix_int___indexed_assignment :: Ptr IMatrix' -> Ptr Slice' -> Ptr Slice' -> Ptr IMatrix' -> IO () casADi__Matrix_int___indexed_assignment :: IMatrix -> Slice -> Slice -> IMatrix -> IO () casADi__Matrix_int___indexed_assignment x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> c_CasADi__Matrix_int___indexed_assignment x0' x1' x2' x3' >>= wrapReturn -- classy wrapper {-| >> void CasADi::Matrix< T >::indexed_assignment(const Slice &rr, const Slice &cc, const Matrix< DataType > &m) > >> void CasADi::Matrix< T >::indexed_assignment(const IndexList &rr, const IndexList &cc, const Matrix< DataType > &m) > >> void CasADi::Matrix< T >::indexed_assignment(const Slice &rr, const Matrix< int > &cc, const Matrix< DataType > &m) > >> void CasADi::Matrix< T >::indexed_assignment(const Matrix< int > &rr, const Slice &cc, const Matrix< DataType > &m) > >> void CasADi::Matrix< T >::indexed_assignment(const Matrix< int > &rr, const IndexList &cc, const Matrix< DataType > &m) > >> void CasADi::Matrix< T >::indexed_assignment(const IndexList &rr, const Matrix< int > &cc, const Matrix< DataType > &m) > >> void CasADi::Matrix< T >::indexed_assignment(const Matrix< int > &rr, const Matrix< int > &cc, const Matrix< DataType > &m) > >> void CasADi::Matrix< T >::indexed_assignment(const Sparsity &sp, const Matrix< DataType > &m) >------------------------------------------------------------------------ >[INTERNAL] >Indexing for interfaced languages get a non-zero > >> void CasADi::Matrix< T >::indexed_assignment(const Slice &rr, const Matrix< DataType > &m) > >> void CasADi::Matrix< T >::indexed_assignment(const IndexList &rr, const Matrix< DataType > &m) >------------------------------------------------------------------------ >[INTERNAL] -} imatrix_indexed_assignment :: IMatrixClass a => a -> Slice -> Slice -> IMatrix -> IO () imatrix_indexed_assignment x = casADi__Matrix_int___indexed_assignment (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___indexed_assignment_TIC" c_CasADi__Matrix_int___indexed_assignment_TIC :: Ptr IMatrix' -> Ptr IndexList' -> Ptr IndexList' -> Ptr IMatrix' -> IO () casADi__Matrix_int___indexed_assignment' :: IMatrix -> IndexList -> IndexList -> IMatrix -> IO () casADi__Matrix_int___indexed_assignment' x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> c_CasADi__Matrix_int___indexed_assignment_TIC x0' x1' x2' x3' >>= wrapReturn -- classy wrapper imatrix_indexed_assignment' :: IMatrixClass a => a -> IndexList -> IndexList -> IMatrix -> IO () imatrix_indexed_assignment' x = casADi__Matrix_int___indexed_assignment' (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___indexed_assignment_TIC_TIC" c_CasADi__Matrix_int___indexed_assignment_TIC_TIC :: Ptr IMatrix' -> Ptr Slice' -> Ptr IMatrix' -> Ptr IMatrix' -> IO () casADi__Matrix_int___indexed_assignment'' :: IMatrix -> Slice -> IMatrix -> IMatrix -> IO () casADi__Matrix_int___indexed_assignment'' x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> c_CasADi__Matrix_int___indexed_assignment_TIC_TIC x0' x1' x2' x3' >>= wrapReturn -- classy wrapper imatrix_indexed_assignment'' :: IMatrixClass a => a -> Slice -> IMatrix -> IMatrix -> IO () imatrix_indexed_assignment'' x = casADi__Matrix_int___indexed_assignment'' (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___indexed_assignment_TIC_TIC_TIC" c_CasADi__Matrix_int___indexed_assignment_TIC_TIC_TIC :: Ptr IMatrix' -> Ptr IMatrix' -> Ptr Slice' -> Ptr IMatrix' -> IO () casADi__Matrix_int___indexed_assignment''' :: IMatrix -> IMatrix -> Slice -> IMatrix -> IO () casADi__Matrix_int___indexed_assignment''' x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> c_CasADi__Matrix_int___indexed_assignment_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn -- classy wrapper imatrix_indexed_assignment''' :: IMatrixClass a => a -> IMatrix -> Slice -> IMatrix -> IO () imatrix_indexed_assignment''' x = casADi__Matrix_int___indexed_assignment''' (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___indexed_assignment_TIC_TIC_TIC_TIC" c_CasADi__Matrix_int___indexed_assignment_TIC_TIC_TIC_TIC :: Ptr IMatrix' -> Ptr IMatrix' -> Ptr IndexList' -> Ptr IMatrix' -> IO () casADi__Matrix_int___indexed_assignment'''' :: IMatrix -> IMatrix -> IndexList -> IMatrix -> IO () casADi__Matrix_int___indexed_assignment'''' x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> c_CasADi__Matrix_int___indexed_assignment_TIC_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn -- classy wrapper imatrix_indexed_assignment'''' :: IMatrixClass a => a -> IMatrix -> IndexList -> IMatrix -> IO () imatrix_indexed_assignment'''' x = casADi__Matrix_int___indexed_assignment'''' (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___indexed_assignment_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_int___indexed_assignment_TIC_TIC_TIC_TIC_TIC :: Ptr IMatrix' -> Ptr IndexList' -> Ptr IMatrix' -> Ptr IMatrix' -> IO () casADi__Matrix_int___indexed_assignment''''' :: IMatrix -> IndexList -> IMatrix -> IMatrix -> IO () casADi__Matrix_int___indexed_assignment''''' x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> c_CasADi__Matrix_int___indexed_assignment_TIC_TIC_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn -- classy wrapper imatrix_indexed_assignment''''' :: IMatrixClass a => a -> IndexList -> IMatrix -> IMatrix -> IO () imatrix_indexed_assignment''''' x = casADi__Matrix_int___indexed_assignment''''' (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_int___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC :: Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> IO () casADi__Matrix_int___indexed_assignment'''''' :: IMatrix -> IMatrix -> IMatrix -> IMatrix -> IO () casADi__Matrix_int___indexed_assignment'''''' x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> c_CasADi__Matrix_int___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn -- classy wrapper imatrix_indexed_assignment'''''' :: IMatrixClass a => a -> IMatrix -> IMatrix -> IMatrix -> IO () imatrix_indexed_assignment'''''' x = casADi__Matrix_int___indexed_assignment'''''' (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_int___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC :: Ptr IMatrix' -> Ptr Sparsity' -> Ptr IMatrix' -> IO () casADi__Matrix_int___indexed_assignment''''''' :: IMatrix -> Sparsity -> IMatrix -> IO () casADi__Matrix_int___indexed_assignment''''''' x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_int___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' >>= wrapReturn -- classy wrapper imatrix_indexed_assignment''''''' :: IMatrixClass a => a -> Sparsity -> IMatrix -> IO () imatrix_indexed_assignment''''''' x = casADi__Matrix_int___indexed_assignment''''''' (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___indexed_one_based_assignment_TIC_TIC" c_CasADi__Matrix_int___indexed_one_based_assignment_TIC_TIC :: Ptr IMatrix' -> CInt -> CInt -> IO () casADi__Matrix_int___indexed_one_based_assignment'' :: IMatrix -> Int -> Int -> IO () casADi__Matrix_int___indexed_one_based_assignment'' x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_int___indexed_one_based_assignment_TIC_TIC x0' x1' x2' >>= wrapReturn -- classy wrapper imatrix_indexed_one_based_assignment'' :: IMatrixClass a => a -> Int -> Int -> IO () imatrix_indexed_one_based_assignment'' x = casADi__Matrix_int___indexed_one_based_assignment'' (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___indexed_zero_based_assignment_TIC_TIC" c_CasADi__Matrix_int___indexed_zero_based_assignment_TIC_TIC :: Ptr IMatrix' -> CInt -> CInt -> IO () casADi__Matrix_int___indexed_zero_based_assignment'' :: IMatrix -> Int -> Int -> IO () casADi__Matrix_int___indexed_zero_based_assignment'' x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_int___indexed_zero_based_assignment_TIC_TIC x0' x1' x2' >>= wrapReturn -- classy wrapper imatrix_indexed_zero_based_assignment'' :: IMatrixClass a => a -> Int -> Int -> IO () imatrix_indexed_zero_based_assignment'' x = casADi__Matrix_int___indexed_zero_based_assignment'' (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_int___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC :: Ptr IMatrix' -> Ptr Slice' -> Ptr IMatrix' -> IO () casADi__Matrix_int___indexed_assignment'''''''' :: IMatrix -> Slice -> IMatrix -> IO () casADi__Matrix_int___indexed_assignment'''''''' x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_int___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' >>= wrapReturn -- classy wrapper imatrix_indexed_assignment'''''''' :: IMatrixClass a => a -> Slice -> IMatrix -> IO () imatrix_indexed_assignment'''''''' x = casADi__Matrix_int___indexed_assignment'''''''' (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_int___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC :: Ptr IMatrix' -> Ptr IndexList' -> Ptr IMatrix' -> IO () casADi__Matrix_int___indexed_assignment''''''''' :: IMatrix -> IndexList -> IMatrix -> IO () casADi__Matrix_int___indexed_assignment''''''''' x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_int___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' >>= wrapReturn -- classy wrapper imatrix_indexed_assignment''''''''' :: IMatrixClass a => a -> IndexList -> IMatrix -> IO () imatrix_indexed_assignment''''''''' x = casADi__Matrix_int___indexed_assignment''''''''' (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___setZero" c_CasADi__Matrix_int___setZero :: Ptr IMatrix' -> IO () casADi__Matrix_int___setZero :: IMatrix -> IO () casADi__Matrix_int___setZero x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_int___setZero x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Set all elements >to zero. -} imatrix_setZero :: IMatrixClass a => a -> IO () imatrix_setZero x = casADi__Matrix_int___setZero (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___setAll" c_CasADi__Matrix_int___setAll :: Ptr IMatrix' -> CInt -> IO () casADi__Matrix_int___setAll :: IMatrix -> Int -> IO () casADi__Matrix_int___setAll x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_int___setAll x0' x1' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Set all elements >to a value. -} imatrix_setAll :: IMatrixClass a => a -> Int -> IO () imatrix_setAll x = casADi__Matrix_int___setAll (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___setSparse" c_CasADi__Matrix_int___setSparse :: Ptr IMatrix' -> Ptr Sparsity' -> CInt -> IO (Ptr IMatrix') casADi__Matrix_int___setSparse :: IMatrix -> Sparsity -> Bool -> IO IMatrix casADi__Matrix_int___setSparse x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_int___setSparse x0' x1' x2' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Set sparse. -} imatrix_setSparse :: IMatrixClass a => a -> Sparsity -> Bool -> IO IMatrix imatrix_setSparse x = casADi__Matrix_int___setSparse (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___setSparse_TIC" c_CasADi__Matrix_int___setSparse_TIC :: Ptr IMatrix' -> Ptr Sparsity' -> IO (Ptr IMatrix') casADi__Matrix_int___setSparse' :: IMatrix -> Sparsity -> IO IMatrix casADi__Matrix_int___setSparse' x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_int___setSparse_TIC x0' x1' >>= wrapReturn -- classy wrapper imatrix_setSparse' :: IMatrixClass a => a -> Sparsity -> IO IMatrix imatrix_setSparse' x = casADi__Matrix_int___setSparse' (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___densify" c_CasADi__Matrix_int___densify :: Ptr IMatrix' -> CInt -> IO () casADi__Matrix_int___densify :: IMatrix -> Int -> IO () casADi__Matrix_int___densify x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_int___densify x0' x1' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Make the matrix >dense. -} imatrix_densify :: IMatrixClass a => a -> Int -> IO () imatrix_densify x = casADi__Matrix_int___densify (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___densify_TIC" c_CasADi__Matrix_int___densify_TIC :: Ptr IMatrix' -> IO () casADi__Matrix_int___densify' :: IMatrix -> IO () casADi__Matrix_int___densify' x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_int___densify_TIC x0' >>= wrapReturn -- classy wrapper imatrix_densify' :: IMatrixClass a => a -> IO () imatrix_densify' x = casADi__Matrix_int___densify' (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___sparsify" c_CasADi__Matrix_int___sparsify :: Ptr IMatrix' -> CDouble -> IO () casADi__Matrix_int___sparsify :: IMatrix -> Double -> IO () casADi__Matrix_int___sparsify x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_int___sparsify x0' x1' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Make a matrix >sparse by removing numerical zeros smaller in absolute value than a >specified tolerance. -} imatrix_sparsify :: IMatrixClass a => a -> Double -> IO () imatrix_sparsify x = casADi__Matrix_int___sparsify (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___sparsify_TIC" c_CasADi__Matrix_int___sparsify_TIC :: Ptr IMatrix' -> IO () casADi__Matrix_int___sparsify' :: IMatrix -> IO () casADi__Matrix_int___sparsify' x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_int___sparsify_TIC x0' >>= wrapReturn -- classy wrapper imatrix_sparsify' :: IMatrixClass a => a -> IO () imatrix_sparsify' x = casADi__Matrix_int___sparsify' (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___operator_plus" c_CasADi__Matrix_int___operator_plus :: Ptr IMatrix' -> IO (Ptr IMatrix') casADi__Matrix_int___operator_plus :: IMatrix -> IO IMatrix casADi__Matrix_int___operator_plus x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_int___operator_plus x0' >>= wrapReturn -- classy wrapper imatrix_operator_plus :: IMatrixClass a => a -> IO IMatrix imatrix_operator_plus x = casADi__Matrix_int___operator_plus (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___operator_minus" c_CasADi__Matrix_int___operator_minus :: Ptr IMatrix' -> IO (Ptr IMatrix') casADi__Matrix_int___operator_minus :: IMatrix -> IO IMatrix casADi__Matrix_int___operator_minus x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_int___operator_minus x0' >>= wrapReturn -- classy wrapper imatrix_operator_minus :: IMatrixClass a => a -> IO IMatrix imatrix_operator_minus x = casADi__Matrix_int___operator_minus (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___binary" c_CasADi__Matrix_int___binary :: CInt -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casADi__Matrix_int___binary :: Int -> IMatrix -> IMatrix -> IO IMatrix casADi__Matrix_int___binary x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_int___binary x0' x1' x2' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Create nodes by >their ID. -} imatrix_binary :: Int -> IMatrix -> IMatrix -> IO IMatrix imatrix_binary = casADi__Matrix_int___binary -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___unary" c_CasADi__Matrix_int___unary :: CInt -> Ptr IMatrix' -> IO (Ptr IMatrix') casADi__Matrix_int___unary :: Int -> IMatrix -> IO IMatrix casADi__Matrix_int___unary x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_int___unary x0' x1' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Create nodes by >their ID. -} imatrix_unary :: Int -> IMatrix -> IO IMatrix imatrix_unary = casADi__Matrix_int___unary -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___scalar_matrix" c_CasADi__Matrix_int___scalar_matrix :: CInt -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casADi__Matrix_int___scalar_matrix :: Int -> IMatrix -> IMatrix -> IO IMatrix casADi__Matrix_int___scalar_matrix x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_int___scalar_matrix x0' x1' x2' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Create >nodes by their ID. -} imatrix_scalar_matrix :: Int -> IMatrix -> IMatrix -> IO IMatrix imatrix_scalar_matrix = casADi__Matrix_int___scalar_matrix -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___matrix_scalar" c_CasADi__Matrix_int___matrix_scalar :: CInt -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casADi__Matrix_int___matrix_scalar :: Int -> IMatrix -> IMatrix -> IO IMatrix casADi__Matrix_int___matrix_scalar x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_int___matrix_scalar x0' x1' x2' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Create >nodes by their ID. -} imatrix_matrix_scalar :: Int -> IMatrix -> IMatrix -> IO IMatrix imatrix_matrix_scalar = casADi__Matrix_int___matrix_scalar -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___matrix_matrix" c_CasADi__Matrix_int___matrix_matrix :: CInt -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casADi__Matrix_int___matrix_matrix :: Int -> IMatrix -> IMatrix -> IO IMatrix casADi__Matrix_int___matrix_matrix x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_int___matrix_matrix x0' x1' x2' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Create >nodes by their ID. -} imatrix_matrix_matrix :: Int -> IMatrix -> IMatrix -> IO IMatrix imatrix_matrix_matrix = casADi__Matrix_int___matrix_matrix -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int_____add__" c_CasADi__Matrix_int_____add__ :: Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casADi__Matrix_int_____add__ :: IMatrix -> IMatrix -> IO IMatrix casADi__Matrix_int_____add__ x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_int_____add__ x0' x1' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Elementwise >operations Octave/Python naming. -} imatrix___add__ :: IMatrixClass a => a -> IMatrix -> IO IMatrix imatrix___add__ x = casADi__Matrix_int_____add__ (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int_____sub__" c_CasADi__Matrix_int_____sub__ :: Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casADi__Matrix_int_____sub__ :: IMatrix -> IMatrix -> IO IMatrix casADi__Matrix_int_____sub__ x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_int_____sub__ x0' x1' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Elementwise >operations Octave/Python naming. -} imatrix___sub__ :: IMatrixClass a => a -> IMatrix -> IO IMatrix imatrix___sub__ x = casADi__Matrix_int_____sub__ (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int_____mul__" c_CasADi__Matrix_int_____mul__ :: Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casADi__Matrix_int_____mul__ :: IMatrix -> IMatrix -> IO IMatrix casADi__Matrix_int_____mul__ x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_int_____mul__ x0' x1' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Elementwise >operations Octave/Python naming. -} imatrix___mul__ :: IMatrixClass a => a -> IMatrix -> IO IMatrix imatrix___mul__ x = casADi__Matrix_int_____mul__ (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int_____div__" c_CasADi__Matrix_int_____div__ :: Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casADi__Matrix_int_____div__ :: IMatrix -> IMatrix -> IO IMatrix casADi__Matrix_int_____div__ x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_int_____div__ x0' x1' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Elementwise >operations Octave/Python naming. -} imatrix___div__ :: IMatrixClass a => a -> IMatrix -> IO IMatrix imatrix___div__ x = casADi__Matrix_int_____div__ (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int_____lt__" c_CasADi__Matrix_int_____lt__ :: Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casADi__Matrix_int_____lt__ :: IMatrix -> IMatrix -> IO IMatrix casADi__Matrix_int_____lt__ x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_int_____lt__ x0' x1' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Elementwise >operations Octave/Python naming. -} imatrix___lt__ :: IMatrixClass a => a -> IMatrix -> IO IMatrix imatrix___lt__ x = casADi__Matrix_int_____lt__ (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int_____le__" c_CasADi__Matrix_int_____le__ :: Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casADi__Matrix_int_____le__ :: IMatrix -> IMatrix -> IO IMatrix casADi__Matrix_int_____le__ x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_int_____le__ x0' x1' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Elementwise >operations Octave/Python naming. -} imatrix___le__ :: IMatrixClass a => a -> IMatrix -> IO IMatrix imatrix___le__ x = casADi__Matrix_int_____le__ (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int_____eq__" c_CasADi__Matrix_int_____eq__ :: Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casADi__Matrix_int_____eq__ :: IMatrix -> IMatrix -> IO IMatrix casADi__Matrix_int_____eq__ x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_int_____eq__ x0' x1' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Elementwise >operations Octave/Python naming. -} imatrix___eq__ :: IMatrixClass a => a -> IMatrix -> IO IMatrix imatrix___eq__ x = casADi__Matrix_int_____eq__ (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int_____ne__" c_CasADi__Matrix_int_____ne__ :: Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casADi__Matrix_int_____ne__ :: IMatrix -> IMatrix -> IO IMatrix casADi__Matrix_int_____ne__ x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_int_____ne__ x0' x1' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Elementwise >operations Octave/Python naming. -} imatrix___ne__ :: IMatrixClass a => a -> IMatrix -> IO IMatrix imatrix___ne__ x = casADi__Matrix_int_____ne__ (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int_____truediv__" c_CasADi__Matrix_int_____truediv__ :: Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casADi__Matrix_int_____truediv__ :: IMatrix -> IMatrix -> IO IMatrix casADi__Matrix_int_____truediv__ x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_int_____truediv__ x0' x1' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Elementwise >operations Octave/Python naming. -} imatrix___truediv__ :: IMatrixClass a => a -> IMatrix -> IO IMatrix imatrix___truediv__ x = casADi__Matrix_int_____truediv__ (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int_____pow__" c_CasADi__Matrix_int_____pow__ :: Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casADi__Matrix_int_____pow__ :: IMatrix -> IMatrix -> IO IMatrix casADi__Matrix_int_____pow__ x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_int_____pow__ x0' x1' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Elementwise >operations Octave/Python naming. -} imatrix___pow__ :: IMatrixClass a => a -> IMatrix -> IO IMatrix imatrix___pow__ x = casADi__Matrix_int_____pow__ (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int_____constpow__" c_CasADi__Matrix_int_____constpow__ :: Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casADi__Matrix_int_____constpow__ :: IMatrix -> IMatrix -> IO IMatrix casADi__Matrix_int_____constpow__ x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_int_____constpow__ x0' x1' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Elementwise >operations Octave/Python naming. -} imatrix___constpow__ :: IMatrixClass a => a -> IMatrix -> IO IMatrix imatrix___constpow__ x = casADi__Matrix_int_____constpow__ (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int_____mpower__" c_CasADi__Matrix_int_____mpower__ :: Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casADi__Matrix_int_____mpower__ :: IMatrix -> IMatrix -> IO IMatrix casADi__Matrix_int_____mpower__ x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_int_____mpower__ x0' x1' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Elementwise >operations Octave/Python naming. -} imatrix___mpower__ :: IMatrixClass a => a -> IMatrix -> IO IMatrix imatrix___mpower__ x = casADi__Matrix_int_____mpower__ (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int_____mrdivide__" c_CasADi__Matrix_int_____mrdivide__ :: Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casADi__Matrix_int_____mrdivide__ :: IMatrix -> IMatrix -> IO IMatrix casADi__Matrix_int_____mrdivide__ x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_int_____mrdivide__ x0' x1' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Elementwise >operations Octave/Python naming. -} imatrix___mrdivide__ :: IMatrixClass a => a -> IMatrix -> IO IMatrix imatrix___mrdivide__ x = casADi__Matrix_int_____mrdivide__ (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___mul_full" c_CasADi__Matrix_int___mul_full :: Ptr IMatrix' -> Ptr IMatrix' -> Ptr Sparsity' -> IO (Ptr IMatrix') casADi__Matrix_int___mul_full :: IMatrix -> IMatrix -> Sparsity -> IO IMatrix casADi__Matrix_int___mul_full x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_int___mul_full x0' x1' x2' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Matrix-matrix >product. -} imatrix_mul_full :: IMatrixClass a => a -> IMatrix -> Sparsity -> IO IMatrix imatrix_mul_full x = casADi__Matrix_int___mul_full (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___mul_full_TIC" c_CasADi__Matrix_int___mul_full_TIC :: Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casADi__Matrix_int___mul_full' :: IMatrix -> IMatrix -> IO IMatrix casADi__Matrix_int___mul_full' x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_int___mul_full_TIC x0' x1' >>= wrapReturn -- classy wrapper imatrix_mul_full' :: IMatrixClass a => a -> IMatrix -> IO IMatrix imatrix_mul_full' x = casADi__Matrix_int___mul_full' (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___mul" c_CasADi__Matrix_int___mul :: Ptr IMatrix' -> Ptr IMatrix' -> Ptr Sparsity' -> IO (Ptr IMatrix') casADi__Matrix_int___mul :: IMatrix -> IMatrix -> Sparsity -> IO IMatrix casADi__Matrix_int___mul x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_int___mul x0' x1' x2' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Matrix-matrix >product. -} imatrix_mul :: IMatrixClass a => a -> IMatrix -> Sparsity -> IO IMatrix imatrix_mul x = casADi__Matrix_int___mul (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___mul_TIC" c_CasADi__Matrix_int___mul_TIC :: Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casADi__Matrix_int___mul' :: IMatrix -> IMatrix -> IO IMatrix casADi__Matrix_int___mul' x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_int___mul_TIC x0' x1' >>= wrapReturn -- classy wrapper imatrix_mul' :: IMatrixClass a => a -> IMatrix -> IO IMatrix imatrix_mul' x = casADi__Matrix_int___mul' (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___mul_no_alloc_nn" c_CasADi__Matrix_int___mul_no_alloc_nn :: Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> IO () casADi__Matrix_int___mul_no_alloc_nn :: IMatrix -> IMatrix -> IMatrix -> IO () casADi__Matrix_int___mul_no_alloc_nn x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_int___mul_no_alloc_nn x0' x1' x2' >>= wrapReturn -- classy wrapper imatrix_mul_no_alloc_nn :: IMatrix -> IMatrix -> IMatrix -> IO () imatrix_mul_no_alloc_nn = casADi__Matrix_int___mul_no_alloc_nn -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___mul_no_alloc_tn" c_CasADi__Matrix_int___mul_no_alloc_tn :: Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> IO () casADi__Matrix_int___mul_no_alloc_tn :: IMatrix -> IMatrix -> IMatrix -> IO () casADi__Matrix_int___mul_no_alloc_tn x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_int___mul_no_alloc_tn x0' x1' x2' >>= wrapReturn -- classy wrapper imatrix_mul_no_alloc_tn :: IMatrix -> IMatrix -> IMatrix -> IO () imatrix_mul_no_alloc_tn = casADi__Matrix_int___mul_no_alloc_tn -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___mul_no_alloc_nt" c_CasADi__Matrix_int___mul_no_alloc_nt :: Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> IO () casADi__Matrix_int___mul_no_alloc_nt :: IMatrix -> IMatrix -> IMatrix -> IO () casADi__Matrix_int___mul_no_alloc_nt x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_int___mul_no_alloc_nt x0' x1' x2' >>= wrapReturn -- classy wrapper imatrix_mul_no_alloc_nt :: IMatrix -> IMatrix -> IMatrix -> IO () imatrix_mul_no_alloc_nt = casADi__Matrix_int___mul_no_alloc_nt -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___mul_no_alloc_tn_TIC" c_CasADi__Matrix_int___mul_no_alloc_tn_TIC :: Ptr IMatrix' -> Ptr (CppVec CInt) -> Ptr (CppVec CInt) -> IO () casADi__Matrix_int___mul_no_alloc_tn' :: IMatrix -> Vector Int -> Vector Int -> IO () casADi__Matrix_int___mul_no_alloc_tn' x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_int___mul_no_alloc_tn_TIC x0' x1' x2' >>= wrapReturn -- classy wrapper imatrix_mul_no_alloc_tn' :: IMatrix -> Vector Int -> Vector Int -> IO () imatrix_mul_no_alloc_tn' = casADi__Matrix_int___mul_no_alloc_tn' -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___mul_no_alloc_nn_TIC" c_CasADi__Matrix_int___mul_no_alloc_nn_TIC :: Ptr IMatrix' -> Ptr (CppVec CInt) -> Ptr (CppVec CInt) -> IO () casADi__Matrix_int___mul_no_alloc_nn' :: IMatrix -> Vector Int -> Vector Int -> IO () casADi__Matrix_int___mul_no_alloc_nn' x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_int___mul_no_alloc_nn_TIC x0' x1' x2' >>= wrapReturn -- classy wrapper imatrix_mul_no_alloc_nn' :: IMatrix -> Vector Int -> Vector Int -> IO () imatrix_mul_no_alloc_nn' = casADi__Matrix_int___mul_no_alloc_nn' -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___quad_form" c_CasADi__Matrix_int___quad_form :: Ptr IMatrix' -> Ptr (CppVec CInt) -> IO CInt casADi__Matrix_int___quad_form :: IMatrix -> Vector Int -> IO Int casADi__Matrix_int___quad_form x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_int___quad_form x0' x1' >>= wrapReturn -- classy wrapper imatrix_quad_form :: IMatrix -> Vector Int -> IO Int imatrix_quad_form = casADi__Matrix_int___quad_form -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___trans" c_CasADi__Matrix_int___trans :: Ptr IMatrix' -> IO (Ptr IMatrix') casADi__Matrix_int___trans :: IMatrix -> IO IMatrix casADi__Matrix_int___trans x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_int___trans x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Transpose the >matrix. -} imatrix_trans :: IMatrixClass a => a -> IO IMatrix imatrix_trans x = casADi__Matrix_int___trans (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___sin" c_CasADi__Matrix_int___sin :: Ptr IMatrix' -> IO (Ptr IMatrix') casADi__Matrix_int___sin :: IMatrix -> IO IMatrix casADi__Matrix_int___sin x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_int___sin x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Operations defined >in the standard namespace for unambigous access and Numpy compatibility. -} imatrix_sin :: IMatrixClass a => a -> IO IMatrix imatrix_sin x = casADi__Matrix_int___sin (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___cos" c_CasADi__Matrix_int___cos :: Ptr IMatrix' -> IO (Ptr IMatrix') casADi__Matrix_int___cos :: IMatrix -> IO IMatrix casADi__Matrix_int___cos x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_int___cos x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Operations defined >in the standard namespace for unambigous access and Numpy compatibility. -} imatrix_cos :: IMatrixClass a => a -> IO IMatrix imatrix_cos x = casADi__Matrix_int___cos (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___tan" c_CasADi__Matrix_int___tan :: Ptr IMatrix' -> IO (Ptr IMatrix') casADi__Matrix_int___tan :: IMatrix -> IO IMatrix casADi__Matrix_int___tan x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_int___tan x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Operations defined >in the standard namespace for unambigous access and Numpy compatibility. -} imatrix_tan :: IMatrixClass a => a -> IO IMatrix imatrix_tan x = casADi__Matrix_int___tan (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___arcsin" c_CasADi__Matrix_int___arcsin :: Ptr IMatrix' -> IO (Ptr IMatrix') casADi__Matrix_int___arcsin :: IMatrix -> IO IMatrix casADi__Matrix_int___arcsin x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_int___arcsin x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Operations >defined in the standard namespace for unambigous access and Numpy >compatibility. -} imatrix_arcsin :: IMatrixClass a => a -> IO IMatrix imatrix_arcsin x = casADi__Matrix_int___arcsin (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___arccos" c_CasADi__Matrix_int___arccos :: Ptr IMatrix' -> IO (Ptr IMatrix') casADi__Matrix_int___arccos :: IMatrix -> IO IMatrix casADi__Matrix_int___arccos x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_int___arccos x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Operations >defined in the standard namespace for unambigous access and Numpy >compatibility. -} imatrix_arccos :: IMatrixClass a => a -> IO IMatrix imatrix_arccos x = casADi__Matrix_int___arccos (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___arctan" c_CasADi__Matrix_int___arctan :: Ptr IMatrix' -> IO (Ptr IMatrix') casADi__Matrix_int___arctan :: IMatrix -> IO IMatrix casADi__Matrix_int___arctan x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_int___arctan x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Operations >defined in the standard namespace for unambigous access and Numpy >compatibility. -} imatrix_arctan :: IMatrixClass a => a -> IO IMatrix imatrix_arctan x = casADi__Matrix_int___arctan (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___exp" c_CasADi__Matrix_int___exp :: Ptr IMatrix' -> IO (Ptr IMatrix') casADi__Matrix_int___exp :: IMatrix -> IO IMatrix casADi__Matrix_int___exp x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_int___exp x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Operations defined >in the standard namespace for unambigous access and Numpy compatibility. -} imatrix_exp :: IMatrixClass a => a -> IO IMatrix imatrix_exp x = casADi__Matrix_int___exp (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___log" c_CasADi__Matrix_int___log :: Ptr IMatrix' -> IO (Ptr IMatrix') casADi__Matrix_int___log :: IMatrix -> IO IMatrix casADi__Matrix_int___log x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_int___log x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Operations defined >in the standard namespace for unambigous access and Numpy compatibility. -} imatrix_log :: IMatrixClass a => a -> IO IMatrix imatrix_log x = casADi__Matrix_int___log (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___sqrt" c_CasADi__Matrix_int___sqrt :: Ptr IMatrix' -> IO (Ptr IMatrix') casADi__Matrix_int___sqrt :: IMatrix -> IO IMatrix casADi__Matrix_int___sqrt x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_int___sqrt x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Operations defined >in the standard namespace for unambigous access and Numpy compatibility. -} imatrix_sqrt :: IMatrixClass a => a -> IO IMatrix imatrix_sqrt x = casADi__Matrix_int___sqrt (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___floor" c_CasADi__Matrix_int___floor :: Ptr IMatrix' -> IO (Ptr IMatrix') casADi__Matrix_int___floor :: IMatrix -> IO IMatrix casADi__Matrix_int___floor x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_int___floor x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Operations defined >in the standard namespace for unambigous access and Numpy compatibility. -} imatrix_floor :: IMatrixClass a => a -> IO IMatrix imatrix_floor x = casADi__Matrix_int___floor (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___ceil" c_CasADi__Matrix_int___ceil :: Ptr IMatrix' -> IO (Ptr IMatrix') casADi__Matrix_int___ceil :: IMatrix -> IO IMatrix casADi__Matrix_int___ceil x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_int___ceil x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Operations defined >in the standard namespace for unambigous access and Numpy compatibility. -} imatrix_ceil :: IMatrixClass a => a -> IO IMatrix imatrix_ceil x = casADi__Matrix_int___ceil (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___fabs" c_CasADi__Matrix_int___fabs :: Ptr IMatrix' -> IO (Ptr IMatrix') casADi__Matrix_int___fabs :: IMatrix -> IO IMatrix casADi__Matrix_int___fabs x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_int___fabs x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Operations defined >in the standard namespace for unambigous access and Numpy compatibility. -} imatrix_fabs :: IMatrixClass a => a -> IO IMatrix imatrix_fabs x = casADi__Matrix_int___fabs (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___sign" c_CasADi__Matrix_int___sign :: Ptr IMatrix' -> IO (Ptr IMatrix') casADi__Matrix_int___sign :: IMatrix -> IO IMatrix casADi__Matrix_int___sign x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_int___sign x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Operations defined >in the standard namespace for unambigous access and Numpy compatibility. -} imatrix_sign :: IMatrixClass a => a -> IO IMatrix imatrix_sign x = casADi__Matrix_int___sign (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int_____copysign__" c_CasADi__Matrix_int_____copysign__ :: Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casADi__Matrix_int_____copysign__ :: IMatrix -> IMatrix -> IO IMatrix casADi__Matrix_int_____copysign__ x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_int_____copysign__ x0' x1' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Operations >defined in the standard namespace for unambigous access and Numpy >compatibility. -} imatrix___copysign__ :: IMatrixClass a => a -> IMatrix -> IO IMatrix imatrix___copysign__ x = casADi__Matrix_int_____copysign__ (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___erfinv" c_CasADi__Matrix_int___erfinv :: Ptr IMatrix' -> IO (Ptr IMatrix') casADi__Matrix_int___erfinv :: IMatrix -> IO IMatrix casADi__Matrix_int___erfinv x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_int___erfinv x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Operations >defined in the standard namespace for unambigous access and Numpy >compatibility. -} imatrix_erfinv :: IMatrixClass a => a -> IO IMatrix imatrix_erfinv x = casADi__Matrix_int___erfinv (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___fmin" c_CasADi__Matrix_int___fmin :: Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casADi__Matrix_int___fmin :: IMatrix -> IMatrix -> IO IMatrix casADi__Matrix_int___fmin x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_int___fmin x0' x1' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Operations defined >in the standard namespace for unambigous access and Numpy compatibility. -} imatrix_fmin :: IMatrixClass a => a -> IMatrix -> IO IMatrix imatrix_fmin x = casADi__Matrix_int___fmin (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___fmax" c_CasADi__Matrix_int___fmax :: Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casADi__Matrix_int___fmax :: IMatrix -> IMatrix -> IO IMatrix casADi__Matrix_int___fmax x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_int___fmax x0' x1' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Operations defined >in the standard namespace for unambigous access and Numpy compatibility. -} imatrix_fmax :: IMatrixClass a => a -> IMatrix -> IO IMatrix imatrix_fmax x = casADi__Matrix_int___fmax (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___erf" c_CasADi__Matrix_int___erf :: Ptr IMatrix' -> IO (Ptr IMatrix') casADi__Matrix_int___erf :: IMatrix -> IO IMatrix casADi__Matrix_int___erf x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_int___erf x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Operations defined >in the standard namespace for unambigous access and Numpy compatibility. -} imatrix_erf :: IMatrixClass a => a -> IO IMatrix imatrix_erf x = casADi__Matrix_int___erf (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___sinh" c_CasADi__Matrix_int___sinh :: Ptr IMatrix' -> IO (Ptr IMatrix') casADi__Matrix_int___sinh :: IMatrix -> IO IMatrix casADi__Matrix_int___sinh x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_int___sinh x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Operations defined >in the standard namespace for unambigous access and Numpy compatibility. -} imatrix_sinh :: IMatrixClass a => a -> IO IMatrix imatrix_sinh x = casADi__Matrix_int___sinh (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___cosh" c_CasADi__Matrix_int___cosh :: Ptr IMatrix' -> IO (Ptr IMatrix') casADi__Matrix_int___cosh :: IMatrix -> IO IMatrix casADi__Matrix_int___cosh x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_int___cosh x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Operations defined >in the standard namespace for unambigous access and Numpy compatibility. -} imatrix_cosh :: IMatrixClass a => a -> IO IMatrix imatrix_cosh x = casADi__Matrix_int___cosh (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___tanh" c_CasADi__Matrix_int___tanh :: Ptr IMatrix' -> IO (Ptr IMatrix') casADi__Matrix_int___tanh :: IMatrix -> IO IMatrix casADi__Matrix_int___tanh x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_int___tanh x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Operations defined >in the standard namespace for unambigous access and Numpy compatibility. -} imatrix_tanh :: IMatrixClass a => a -> IO IMatrix imatrix_tanh x = casADi__Matrix_int___tanh (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___arcsinh" c_CasADi__Matrix_int___arcsinh :: Ptr IMatrix' -> IO (Ptr IMatrix') casADi__Matrix_int___arcsinh :: IMatrix -> IO IMatrix casADi__Matrix_int___arcsinh x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_int___arcsinh x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Operations >defined in the standard namespace for unambigous access and Numpy >compatibility. -} imatrix_arcsinh :: IMatrixClass a => a -> IO IMatrix imatrix_arcsinh x = casADi__Matrix_int___arcsinh (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___arccosh" c_CasADi__Matrix_int___arccosh :: Ptr IMatrix' -> IO (Ptr IMatrix') casADi__Matrix_int___arccosh :: IMatrix -> IO IMatrix casADi__Matrix_int___arccosh x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_int___arccosh x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Operations >defined in the standard namespace for unambigous access and Numpy >compatibility. -} imatrix_arccosh :: IMatrixClass a => a -> IO IMatrix imatrix_arccosh x = casADi__Matrix_int___arccosh (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___arctanh" c_CasADi__Matrix_int___arctanh :: Ptr IMatrix' -> IO (Ptr IMatrix') casADi__Matrix_int___arctanh :: IMatrix -> IO IMatrix casADi__Matrix_int___arctanh x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_int___arctanh x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Operations >defined in the standard namespace for unambigous access and Numpy >compatibility. -} imatrix_arctanh :: IMatrixClass a => a -> IO IMatrix imatrix_arctanh x = casADi__Matrix_int___arctanh (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___arctan2" c_CasADi__Matrix_int___arctan2 :: Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casADi__Matrix_int___arctan2 :: IMatrix -> IMatrix -> IO IMatrix casADi__Matrix_int___arctan2 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_int___arctan2 x0' x1' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Operations >defined in the standard namespace for unambigous access and Numpy >compatibility. -} imatrix_arctan2 :: IMatrixClass a => a -> IMatrix -> IO IMatrix imatrix_arctan2 x = casADi__Matrix_int___arctan2 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___log10" c_CasADi__Matrix_int___log10 :: Ptr IMatrix' -> IO (Ptr IMatrix') casADi__Matrix_int___log10 :: IMatrix -> IO IMatrix casADi__Matrix_int___log10 x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_int___log10 x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Operations defined >in the standard namespace for unambigous access and Numpy compatibility. -} imatrix_log10 :: IMatrixClass a => a -> IO IMatrix imatrix_log10 x = casADi__Matrix_int___log10 (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___printme" c_CasADi__Matrix_int___printme :: Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casADi__Matrix_int___printme :: IMatrix -> IMatrix -> IO IMatrix casADi__Matrix_int___printme x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_int___printme x0' x1' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Operations >defined in the standard namespace for unambigous access and Numpy >compatibility. -} imatrix_printme :: IMatrixClass a => a -> IMatrix -> IO IMatrix imatrix_printme x = casADi__Matrix_int___printme (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___logic_not" c_CasADi__Matrix_int___logic_not :: Ptr IMatrix' -> IO (Ptr IMatrix') casADi__Matrix_int___logic_not :: IMatrix -> IO IMatrix casADi__Matrix_int___logic_not x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_int___logic_not x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Operations >defined in the standard namespace for unambigous access and Numpy >compatibility. -} imatrix_logic_not :: IMatrixClass a => a -> IO IMatrix imatrix_logic_not x = casADi__Matrix_int___logic_not (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___logic_and" c_CasADi__Matrix_int___logic_and :: Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casADi__Matrix_int___logic_and :: IMatrix -> IMatrix -> IO IMatrix casADi__Matrix_int___logic_and x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_int___logic_and x0' x1' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Operations >defined in the standard namespace for unambigous access and Numpy >compatibility. -} imatrix_logic_and :: IMatrixClass a => a -> IMatrix -> IO IMatrix imatrix_logic_and x = casADi__Matrix_int___logic_and (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___logic_or" c_CasADi__Matrix_int___logic_or :: Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casADi__Matrix_int___logic_or :: IMatrix -> IMatrix -> IO IMatrix casADi__Matrix_int___logic_or x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_int___logic_or x0' x1' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Operations >defined in the standard namespace for unambigous access and Numpy >compatibility. -} imatrix_logic_or :: IMatrixClass a => a -> IMatrix -> IO IMatrix imatrix_logic_or x = casADi__Matrix_int___logic_or (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___if_else_zero" c_CasADi__Matrix_int___if_else_zero :: Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') casADi__Matrix_int___if_else_zero :: IMatrix -> IMatrix -> IO IMatrix casADi__Matrix_int___if_else_zero x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_int___if_else_zero x0' x1' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Operations >defined in the standard namespace for unambigous access and Numpy >compatibility. -} imatrix_if_else_zero :: IMatrixClass a => a -> IMatrix -> IO IMatrix imatrix_if_else_zero x = casADi__Matrix_int___if_else_zero (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___setMaxNumCallsInPrint" c_CasADi__Matrix_int___setMaxNumCallsInPrint :: CLong -> IO () casADi__Matrix_int___setMaxNumCallsInPrint :: Int -> IO () casADi__Matrix_int___setMaxNumCallsInPrint x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_int___setMaxNumCallsInPrint x0' >>= wrapReturn -- classy wrapper imatrix_setMaxNumCallsInPrint :: Int -> IO () imatrix_setMaxNumCallsInPrint = casADi__Matrix_int___setMaxNumCallsInPrint -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___setMaxNumCallsInPrint_TIC" c_CasADi__Matrix_int___setMaxNumCallsInPrint_TIC :: IO () casADi__Matrix_int___setMaxNumCallsInPrint' :: IO () casADi__Matrix_int___setMaxNumCallsInPrint' = c_CasADi__Matrix_int___setMaxNumCallsInPrint_TIC >>= wrapReturn -- classy wrapper imatrix_setMaxNumCallsInPrint' :: IO () imatrix_setMaxNumCallsInPrint' = casADi__Matrix_int___setMaxNumCallsInPrint' -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___getMaxNumCallsInPrint" c_CasADi__Matrix_int___getMaxNumCallsInPrint :: IO CLong casADi__Matrix_int___getMaxNumCallsInPrint :: IO Int casADi__Matrix_int___getMaxNumCallsInPrint = c_CasADi__Matrix_int___getMaxNumCallsInPrint >>= wrapReturn -- classy wrapper imatrix_getMaxNumCallsInPrint :: IO Int imatrix_getMaxNumCallsInPrint = casADi__Matrix_int___getMaxNumCallsInPrint -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___setEqualityCheckingDepth" c_CasADi__Matrix_int___setEqualityCheckingDepth :: CInt -> IO () casADi__Matrix_int___setEqualityCheckingDepth :: Int -> IO () casADi__Matrix_int___setEqualityCheckingDepth x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_int___setEqualityCheckingDepth x0' >>= wrapReturn -- classy wrapper imatrix_setEqualityCheckingDepth :: Int -> IO () imatrix_setEqualityCheckingDepth = casADi__Matrix_int___setEqualityCheckingDepth -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___setEqualityCheckingDepth_TIC" c_CasADi__Matrix_int___setEqualityCheckingDepth_TIC :: IO () casADi__Matrix_int___setEqualityCheckingDepth' :: IO () casADi__Matrix_int___setEqualityCheckingDepth' = c_CasADi__Matrix_int___setEqualityCheckingDepth_TIC >>= wrapReturn -- classy wrapper imatrix_setEqualityCheckingDepth' :: IO () imatrix_setEqualityCheckingDepth' = casADi__Matrix_int___setEqualityCheckingDepth' -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___getEqualityCheckingDepth" c_CasADi__Matrix_int___getEqualityCheckingDepth :: IO CInt casADi__Matrix_int___getEqualityCheckingDepth :: IO Int casADi__Matrix_int___getEqualityCheckingDepth = c_CasADi__Matrix_int___getEqualityCheckingDepth >>= wrapReturn -- classy wrapper imatrix_getEqualityCheckingDepth :: IO Int imatrix_getEqualityCheckingDepth = casADi__Matrix_int___getEqualityCheckingDepth -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___className" c_CasADi__Matrix_int___className :: IO (Ptr StdString') casADi__Matrix_int___className :: IO String casADi__Matrix_int___className = c_CasADi__Matrix_int___className >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Printing. -} imatrix_className :: IO String imatrix_className = casADi__Matrix_int___className -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___printScalar_TIC" c_CasADi__Matrix_int___printScalar_TIC :: Ptr IMatrix' -> IO () casADi__Matrix_int___printScalar' :: IMatrix -> IO () casADi__Matrix_int___printScalar' x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_int___printScalar_TIC x0' >>= wrapReturn -- classy wrapper imatrix_printScalar' :: IMatrixClass a => a -> IO () imatrix_printScalar' x = casADi__Matrix_int___printScalar' (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___printVector_TIC" c_CasADi__Matrix_int___printVector_TIC :: Ptr IMatrix' -> IO () casADi__Matrix_int___printVector' :: IMatrix -> IO () casADi__Matrix_int___printVector' x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_int___printVector_TIC x0' >>= wrapReturn -- classy wrapper imatrix_printVector' :: IMatrixClass a => a -> IO () imatrix_printVector' x = casADi__Matrix_int___printVector' (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___printDense_TIC" c_CasADi__Matrix_int___printDense_TIC :: Ptr IMatrix' -> IO () casADi__Matrix_int___printDense' :: IMatrix -> IO () casADi__Matrix_int___printDense' x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_int___printDense_TIC x0' >>= wrapReturn -- classy wrapper imatrix_printDense' :: IMatrixClass a => a -> IO () imatrix_printDense' x = casADi__Matrix_int___printDense' (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___printSparse_TIC" c_CasADi__Matrix_int___printSparse_TIC :: Ptr IMatrix' -> IO () casADi__Matrix_int___printSparse' :: IMatrix -> IO () casADi__Matrix_int___printSparse' x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_int___printSparse_TIC x0' >>= wrapReturn -- classy wrapper imatrix_printSparse' :: IMatrixClass a => a -> IO () imatrix_printSparse' x = casADi__Matrix_int___printSparse' (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___row" c_CasADi__Matrix_int___row :: Ptr IMatrix' -> CInt -> IO CInt casADi__Matrix_int___row :: IMatrix -> Int -> IO Int casADi__Matrix_int___row x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_int___row x0' x1' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] -} imatrix_row :: IMatrixClass a => a -> Int -> IO Int imatrix_row x = casADi__Matrix_int___row (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___colind" c_CasADi__Matrix_int___colind :: Ptr IMatrix' -> CInt -> IO CInt casADi__Matrix_int___colind :: IMatrix -> Int -> IO Int casADi__Matrix_int___colind x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_int___colind x0' x1' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] -} imatrix_colind :: IMatrixClass a => a -> Int -> IO Int imatrix_colind x = casADi__Matrix_int___colind (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___clear" c_CasADi__Matrix_int___clear :: Ptr IMatrix' -> IO () casADi__Matrix_int___clear :: IMatrix -> IO () casADi__Matrix_int___clear x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_int___clear x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] -} imatrix_clear :: IMatrixClass a => a -> IO () imatrix_clear x = casADi__Matrix_int___clear (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___resize" c_CasADi__Matrix_int___resize :: Ptr IMatrix' -> CInt -> CInt -> IO () casADi__Matrix_int___resize :: IMatrix -> Int -> Int -> IO () casADi__Matrix_int___resize x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_int___resize x0' x1' x2' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] -} imatrix_resize :: IMatrixClass a => a -> Int -> Int -> IO () imatrix_resize x = casADi__Matrix_int___resize (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___reserve" c_CasADi__Matrix_int___reserve :: Ptr IMatrix' -> CInt -> IO () casADi__Matrix_int___reserve :: IMatrix -> Int -> IO () casADi__Matrix_int___reserve x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_int___reserve x0' x1' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] -} imatrix_reserve :: IMatrixClass a => a -> Int -> IO () imatrix_reserve x = casADi__Matrix_int___reserve (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___reserve_TIC" c_CasADi__Matrix_int___reserve_TIC :: Ptr IMatrix' -> CInt -> CInt -> IO () casADi__Matrix_int___reserve' :: IMatrix -> Int -> Int -> IO () casADi__Matrix_int___reserve' x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_int___reserve_TIC x0' x1' x2' >>= wrapReturn -- classy wrapper imatrix_reserve' :: IMatrixClass a => a -> Int -> Int -> IO () imatrix_reserve' x = casADi__Matrix_int___reserve' (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___erase" c_CasADi__Matrix_int___erase :: Ptr IMatrix' -> Ptr (CppVec CInt) -> Ptr (CppVec CInt) -> IO () casADi__Matrix_int___erase :: IMatrix -> Vector Int -> Vector Int -> IO () casADi__Matrix_int___erase x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_int___erase x0' x1' x2' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Erase a submatrix >Erase rows and/or columns of a matrix. -} imatrix_erase :: IMatrixClass a => a -> Vector Int -> Vector Int -> IO () imatrix_erase x = casADi__Matrix_int___erase (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___remove" c_CasADi__Matrix_int___remove :: Ptr IMatrix' -> Ptr (CppVec CInt) -> Ptr (CppVec CInt) -> IO () casADi__Matrix_int___remove :: IMatrix -> Vector Int -> Vector Int -> IO () casADi__Matrix_int___remove x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_int___remove x0' x1' x2' >>= wrapReturn -- classy wrapper {-| > [INTERNAL] Remove cols or >rows Rremove/delete rows and/or columns of a matrix. -} imatrix_remove :: IMatrixClass a => a -> Vector Int -> Vector Int -> IO () imatrix_remove x = casADi__Matrix_int___remove (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___enlarge" c_CasADi__Matrix_int___enlarge :: Ptr IMatrix' -> CInt -> CInt -> Ptr (CppVec CInt) -> Ptr (CppVec CInt) -> IO () casADi__Matrix_int___enlarge :: IMatrix -> Int -> Int -> Vector Int -> Vector Int -> IO () casADi__Matrix_int___enlarge x0 x1 x2 x3 x4 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> withMarshal x4 $ \x4' -> c_CasADi__Matrix_int___enlarge x0' x1' x2' x3' x4' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Enlarge matrix >Make the matrix larger by inserting empty rows and columns, keeping the >existing non-zeros. -} imatrix_enlarge :: IMatrixClass a => a -> Int -> Int -> Vector Int -> Vector Int -> IO () imatrix_enlarge x = casADi__Matrix_int___enlarge (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___data" c_CasADi__Matrix_int___data :: Ptr IMatrix' -> IO (Ptr (CppVec CInt)) casADi__Matrix_int___data :: IMatrix -> IO (Vector Int) casADi__Matrix_int___data x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_int___data x0' >>= wrapReturn -- classy wrapper {-| >> std::vector< DataType > & CasADi::Matrix< DataType >::data() >------------------------------------------------------------------------ >[INTERNAL] >Access the non-zero elements. > >> const std::vector< DataType > & CasADi::Matrix< DataType >::data() const >------------------------------------------------------------------------ >[INTERNAL] >Const access the non-zero elements. -} imatrix_data :: IMatrixClass a => a -> IO (Vector Int) imatrix_data x = casADi__Matrix_int___data (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___sparsityRef" c_CasADi__Matrix_int___sparsityRef :: Ptr IMatrix' -> IO (Ptr Sparsity') casADi__Matrix_int___sparsityRef :: IMatrix -> IO Sparsity casADi__Matrix_int___sparsityRef x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_int___sparsityRef x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Access the >sparsity, make a copy if there are multiple references to it. -} imatrix_sparsityRef :: IMatrixClass a => a -> IO Sparsity imatrix_sparsityRef x = casADi__Matrix_int___sparsityRef (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___set" c_CasADi__Matrix_int___set :: Ptr IMatrix' -> CInt -> CInt -> IO () casADi__Matrix_int___set :: IMatrix -> Int -> SparsityType -> IO () casADi__Matrix_int___set x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_int___set x0' x1' x2' >>= wrapReturn -- classy wrapper {-| >> void CasADi::Matrix< DataType >::set(DataType val, SparsityType sp=SPARSE) >------------------------------------------------------------------------ >[INTERNAL] >Set the non-zero elements, scalar. > >> void CasADi::Matrix< DataType >::set(const std::vector< DataType > &val, SparsityType sp=SPARSE) >------------------------------------------------------------------------ >[INTERNAL] >Set the non-zero elements, vector. > >> void CasADi::Matrix< DataType >::set(const Matrix< DataType > &val, SparsityType sp=SPARSE) >------------------------------------------------------------------------ >[INTERNAL] >Set the non-zero elements, Matrix. > >> void CasADi::Matrix< DataType >::set(const DataType *val, SparsityType sp=SPARSE) >------------------------------------------------------------------------ >[INTERNAL] >Legacy - use setArray instead. -} imatrix_set :: IMatrixClass a => a -> Int -> SparsityType -> IO () imatrix_set x = casADi__Matrix_int___set (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___set_TIC" c_CasADi__Matrix_int___set_TIC :: Ptr IMatrix' -> CInt -> IO () casADi__Matrix_int___set' :: IMatrix -> Int -> IO () casADi__Matrix_int___set' x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_int___set_TIC x0' x1' >>= wrapReturn -- classy wrapper imatrix_set' :: IMatrixClass a => a -> Int -> IO () imatrix_set' x = casADi__Matrix_int___set' (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___get" c_CasADi__Matrix_int___get :: Ptr IMatrix' -> CInt -> CInt -> IO () casADi__Matrix_int___get :: IMatrix -> Int -> SparsityType -> IO () casADi__Matrix_int___get x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_int___get x0' x1' x2' >>= wrapReturn -- classy wrapper {-| >> void CasADi::Matrix< DataType >::get(DataType &val, SparsityType sp=SPARSE) const >------------------------------------------------------------------------ >[INTERNAL] >Get the non-zero elements, scalar. > >> void CasADi::Matrix< DataType >::get(std::vector< DataType > &val, SparsityType sp=SPARSE) const >------------------------------------------------------------------------ >[INTERNAL] >Get the non-zero elements, vector. > >> void CasADi::Matrix< DataType >::get(Matrix< DataType > &val, SparsityType sp=SPARSE) const >------------------------------------------------------------------------ >[INTERNAL] >Get the non-zero elements, Matrix. > >> void CasADi::Matrix< DataType >::get(DataType *val, SparsityType sp=SPARSE) const >------------------------------------------------------------------------ >[INTERNAL] >Legacy - use getArray instead. -} imatrix_get :: IMatrixClass a => a -> Int -> SparsityType -> IO () imatrix_get x = casADi__Matrix_int___get (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___get_TIC" c_CasADi__Matrix_int___get_TIC :: Ptr IMatrix' -> CInt -> IO () casADi__Matrix_int___get' :: IMatrix -> Int -> IO () casADi__Matrix_int___get' x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_int___get_TIC x0' x1' >>= wrapReturn -- classy wrapper imatrix_get' :: IMatrixClass a => a -> Int -> IO () imatrix_get' x = casADi__Matrix_int___get' (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___set_TIC_TIC" c_CasADi__Matrix_int___set_TIC_TIC :: Ptr IMatrix' -> Ptr (CppVec CInt) -> CInt -> IO () casADi__Matrix_int___set'' :: IMatrix -> Vector Int -> SparsityType -> IO () casADi__Matrix_int___set'' x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_int___set_TIC_TIC x0' x1' x2' >>= wrapReturn -- classy wrapper imatrix_set'' :: IMatrixClass a => a -> Vector Int -> SparsityType -> IO () imatrix_set'' x = casADi__Matrix_int___set'' (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___set_TIC_TIC_TIC" c_CasADi__Matrix_int___set_TIC_TIC_TIC :: Ptr IMatrix' -> Ptr (CppVec CInt) -> IO () casADi__Matrix_int___set''' :: IMatrix -> Vector Int -> IO () casADi__Matrix_int___set''' x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_int___set_TIC_TIC_TIC x0' x1' >>= wrapReturn -- classy wrapper imatrix_set''' :: IMatrixClass a => a -> Vector Int -> IO () imatrix_set''' x = casADi__Matrix_int___set''' (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___get_TIC_TIC" c_CasADi__Matrix_int___get_TIC_TIC :: Ptr IMatrix' -> Ptr (CppVec CInt) -> CInt -> IO () casADi__Matrix_int___get'' :: IMatrix -> Vector Int -> SparsityType -> IO () casADi__Matrix_int___get'' x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_int___get_TIC_TIC x0' x1' x2' >>= wrapReturn -- classy wrapper imatrix_get'' :: IMatrixClass a => a -> Vector Int -> SparsityType -> IO () imatrix_get'' x = casADi__Matrix_int___get'' (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___get_TIC_TIC_TIC" c_CasADi__Matrix_int___get_TIC_TIC_TIC :: Ptr IMatrix' -> Ptr (CppVec CInt) -> IO () casADi__Matrix_int___get''' :: IMatrix -> Vector Int -> IO () casADi__Matrix_int___get''' x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_int___get_TIC_TIC_TIC x0' x1' >>= wrapReturn -- classy wrapper imatrix_get''' :: IMatrixClass a => a -> Vector Int -> IO () imatrix_get''' x = casADi__Matrix_int___get''' (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___set_TIC_TIC_TIC_TIC" c_CasADi__Matrix_int___set_TIC_TIC_TIC_TIC :: Ptr IMatrix' -> Ptr IMatrix' -> CInt -> IO () casADi__Matrix_int___set'''' :: IMatrix -> IMatrix -> SparsityType -> IO () casADi__Matrix_int___set'''' x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_int___set_TIC_TIC_TIC_TIC x0' x1' x2' >>= wrapReturn -- classy wrapper imatrix_set'''' :: IMatrixClass a => a -> IMatrix -> SparsityType -> IO () imatrix_set'''' x = casADi__Matrix_int___set'''' (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___set_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_int___set_TIC_TIC_TIC_TIC_TIC :: Ptr IMatrix' -> Ptr IMatrix' -> IO () casADi__Matrix_int___set''''' :: IMatrix -> IMatrix -> IO () casADi__Matrix_int___set''''' x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_int___set_TIC_TIC_TIC_TIC_TIC x0' x1' >>= wrapReturn -- classy wrapper imatrix_set''''' :: IMatrixClass a => a -> IMatrix -> IO () imatrix_set''''' x = casADi__Matrix_int___set''''' (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___get_TIC_TIC_TIC_TIC" c_CasADi__Matrix_int___get_TIC_TIC_TIC_TIC :: Ptr IMatrix' -> Ptr IMatrix' -> CInt -> IO () casADi__Matrix_int___get'''' :: IMatrix -> IMatrix -> SparsityType -> IO () casADi__Matrix_int___get'''' x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_int___get_TIC_TIC_TIC_TIC x0' x1' x2' >>= wrapReturn -- classy wrapper imatrix_get'''' :: IMatrixClass a => a -> IMatrix -> SparsityType -> IO () imatrix_get'''' x = casADi__Matrix_int___get'''' (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___get_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_int___get_TIC_TIC_TIC_TIC_TIC :: Ptr IMatrix' -> Ptr IMatrix' -> IO () casADi__Matrix_int___get''''' :: IMatrix -> IMatrix -> IO () casADi__Matrix_int___get''''' x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_int___get_TIC_TIC_TIC_TIC_TIC x0' x1' >>= wrapReturn -- classy wrapper imatrix_get''''' :: IMatrixClass a => a -> IMatrix -> IO () imatrix_get''''' x = casADi__Matrix_int___get''''' (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___triplet" c_CasADi__Matrix_int___triplet :: Ptr (CppVec CInt) -> Ptr (CppVec CInt) -> Ptr (CppVec CInt) -> IO (Ptr IMatrix') casADi__Matrix_int___triplet :: Vector Int -> Vector Int -> Vector Int -> IO IMatrix casADi__Matrix_int___triplet x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_int___triplet x0' x1' x2' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] -} imatrix_triplet :: Vector Int -> Vector Int -> Vector Int -> IO IMatrix imatrix_triplet = casADi__Matrix_int___triplet -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___triplet_TIC" c_CasADi__Matrix_int___triplet_TIC :: Ptr (CppVec CInt) -> Ptr (CppVec CInt) -> Ptr (CppVec CInt) -> CInt -> CInt -> IO (Ptr IMatrix') casADi__Matrix_int___triplet' :: Vector Int -> Vector Int -> Vector Int -> Int -> Int -> IO IMatrix casADi__Matrix_int___triplet' x0 x1 x2 x3 x4 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> withMarshal x4 $ \x4' -> c_CasADi__Matrix_int___triplet_TIC x0' x1' x2' x3' x4' >>= wrapReturn -- classy wrapper imatrix_triplet' :: Vector Int -> Vector Int -> Vector Int -> Int -> Int -> IO IMatrix imatrix_triplet' = casADi__Matrix_int___triplet' -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___inf" c_CasADi__Matrix_int___inf :: Ptr Sparsity' -> IO (Ptr IMatrix') casADi__Matrix_int___inf :: Sparsity -> IO IMatrix casADi__Matrix_int___inf x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_int___inf x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] create a matrix with >all inf -} imatrix_inf :: Sparsity -> IO IMatrix imatrix_inf = casADi__Matrix_int___inf -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___inf_TIC" c_CasADi__Matrix_int___inf_TIC :: CInt -> CInt -> IO (Ptr IMatrix') casADi__Matrix_int___inf' :: Int -> Int -> IO IMatrix casADi__Matrix_int___inf' x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_int___inf_TIC x0' x1' >>= wrapReturn -- classy wrapper imatrix_inf' :: Int -> Int -> IO IMatrix imatrix_inf' = casADi__Matrix_int___inf' -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___inf_TIC_TIC" c_CasADi__Matrix_int___inf_TIC_TIC :: CInt -> IO (Ptr IMatrix') casADi__Matrix_int___inf'' :: Int -> IO IMatrix casADi__Matrix_int___inf'' x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_int___inf_TIC_TIC x0' >>= wrapReturn -- classy wrapper imatrix_inf'' :: Int -> IO IMatrix imatrix_inf'' = casADi__Matrix_int___inf'' -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___inf_TIC_TIC_TIC" c_CasADi__Matrix_int___inf_TIC_TIC_TIC :: IO (Ptr IMatrix') casADi__Matrix_int___inf''' :: IO IMatrix casADi__Matrix_int___inf''' = c_CasADi__Matrix_int___inf_TIC_TIC_TIC >>= wrapReturn -- classy wrapper imatrix_inf''' :: IO IMatrix imatrix_inf''' = casADi__Matrix_int___inf''' -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___nan" c_CasADi__Matrix_int___nan :: Ptr Sparsity' -> IO (Ptr IMatrix') casADi__Matrix_int___nan :: Sparsity -> IO IMatrix casADi__Matrix_int___nan x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_int___nan x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] create a matrix with >all nan -} imatrix_nan :: Sparsity -> IO IMatrix imatrix_nan = casADi__Matrix_int___nan -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___nan_TIC" c_CasADi__Matrix_int___nan_TIC :: CInt -> CInt -> IO (Ptr IMatrix') casADi__Matrix_int___nan' :: Int -> Int -> IO IMatrix casADi__Matrix_int___nan' x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_int___nan_TIC x0' x1' >>= wrapReturn -- classy wrapper imatrix_nan' :: Int -> Int -> IO IMatrix imatrix_nan' = casADi__Matrix_int___nan' -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___nan_TIC_TIC" c_CasADi__Matrix_int___nan_TIC_TIC :: CInt -> IO (Ptr IMatrix') casADi__Matrix_int___nan'' :: Int -> IO IMatrix casADi__Matrix_int___nan'' x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_int___nan_TIC_TIC x0' >>= wrapReturn -- classy wrapper imatrix_nan'' :: Int -> IO IMatrix imatrix_nan'' = casADi__Matrix_int___nan'' -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___nan_TIC_TIC_TIC" c_CasADi__Matrix_int___nan_TIC_TIC_TIC :: IO (Ptr IMatrix') casADi__Matrix_int___nan''' :: IO IMatrix casADi__Matrix_int___nan''' = c_CasADi__Matrix_int___nan_TIC_TIC_TIC >>= wrapReturn -- classy wrapper imatrix_nan''' :: IO IMatrix imatrix_nan''' = casADi__Matrix_int___nan''' -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___repmat" c_CasADi__Matrix_int___repmat :: CInt -> Ptr Sparsity' -> IO (Ptr IMatrix') casADi__Matrix_int___repmat :: Int -> Sparsity -> IO IMatrix casADi__Matrix_int___repmat x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_int___repmat x0' x1' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] create a matrix >by repeating an existing matrix -} imatrix_repmat :: Int -> Sparsity -> IO IMatrix imatrix_repmat = casADi__Matrix_int___repmat -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___repmat_TIC" c_CasADi__Matrix_int___repmat_TIC :: Ptr IMatrix' -> Ptr Sparsity' -> IO (Ptr IMatrix') casADi__Matrix_int___repmat' :: IMatrix -> Sparsity -> IO IMatrix casADi__Matrix_int___repmat' x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_int___repmat_TIC x0' x1' >>= wrapReturn -- classy wrapper imatrix_repmat' :: IMatrix -> Sparsity -> IO IMatrix imatrix_repmat' = casADi__Matrix_int___repmat' -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___repmat_TIC_TIC" c_CasADi__Matrix_int___repmat_TIC_TIC :: Ptr IMatrix' -> CInt -> CInt -> IO (Ptr IMatrix') casADi__Matrix_int___repmat'' :: IMatrix -> Int -> Int -> IO IMatrix casADi__Matrix_int___repmat'' x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_int___repmat_TIC_TIC x0' x1' x2' >>= wrapReturn -- classy wrapper imatrix_repmat'' :: IMatrix -> Int -> Int -> IO IMatrix imatrix_repmat'' = casADi__Matrix_int___repmat'' -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___repmat_TIC_TIC_TIC" c_CasADi__Matrix_int___repmat_TIC_TIC_TIC :: Ptr IMatrix' -> CInt -> IO (Ptr IMatrix') casADi__Matrix_int___repmat''' :: IMatrix -> Int -> IO IMatrix casADi__Matrix_int___repmat''' x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_int___repmat_TIC_TIC_TIC x0' x1' >>= wrapReturn -- classy wrapper imatrix_repmat''' :: IMatrix -> Int -> IO IMatrix imatrix_repmat''' = casADi__Matrix_int___repmat''' -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___eye" c_CasADi__Matrix_int___eye :: CInt -> IO (Ptr IMatrix') casADi__Matrix_int___eye :: Int -> IO IMatrix casADi__Matrix_int___eye x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_int___eye x0' >>= wrapReturn -- classy wrapper imatrix_eye :: Int -> IO IMatrix imatrix_eye = casADi__Matrix_int___eye -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___isRegular" c_CasADi__Matrix_int___isRegular :: Ptr IMatrix' -> IO CInt casADi__Matrix_int___isRegular :: IMatrix -> IO Bool casADi__Matrix_int___isRegular x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_int___isRegular x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Checks if >expression does not contain NaN or Inf. -} imatrix_isRegular :: IMatrixClass a => a -> IO Bool imatrix_isRegular x = casADi__Matrix_int___isRegular (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___isSmooth" c_CasADi__Matrix_int___isSmooth :: Ptr IMatrix' -> IO CInt casADi__Matrix_int___isSmooth :: IMatrix -> IO Bool casADi__Matrix_int___isSmooth x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_int___isSmooth x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Check if >smooth. -} imatrix_isSmooth :: IMatrixClass a => a -> IO Bool imatrix_isSmooth x = casADi__Matrix_int___isSmooth (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___isSymbolic" c_CasADi__Matrix_int___isSymbolic :: Ptr IMatrix' -> IO CInt casADi__Matrix_int___isSymbolic :: IMatrix -> IO Bool casADi__Matrix_int___isSymbolic x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_int___isSymbolic x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Check if >symbolic (Dense) Sparse matrices invariable return false. -} imatrix_isSymbolic :: IMatrixClass a => a -> IO Bool imatrix_isSymbolic x = casADi__Matrix_int___isSymbolic (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___isSymbolicSparse" c_CasADi__Matrix_int___isSymbolicSparse :: Ptr IMatrix' -> IO CInt casADi__Matrix_int___isSymbolicSparse :: IMatrix -> IO Bool casADi__Matrix_int___isSymbolicSparse x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_int___isSymbolicSparse x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Check >if symbolic Sparse matrices can return true if all non-zero elements are >symbolic. -} imatrix_isSymbolicSparse :: IMatrixClass a => a -> IO Bool imatrix_isSymbolicSparse x = casADi__Matrix_int___isSymbolicSparse (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___isConstant" c_CasADi__Matrix_int___isConstant :: Ptr IMatrix' -> IO CInt casADi__Matrix_int___isConstant :: IMatrix -> IO Bool casADi__Matrix_int___isConstant x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_int___isConstant x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Check if the >matrix is constant (note that false negative answers are possible) -} imatrix_isConstant :: IMatrixClass a => a -> IO Bool imatrix_isConstant x = casADi__Matrix_int___isConstant (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___isInteger" c_CasADi__Matrix_int___isInteger :: Ptr IMatrix' -> IO CInt casADi__Matrix_int___isInteger :: IMatrix -> IO Bool casADi__Matrix_int___isInteger x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_int___isInteger x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Check if the >matrix is integer-valued (note that false negative answers are possible) -} imatrix_isInteger :: IMatrixClass a => a -> IO Bool imatrix_isInteger x = casADi__Matrix_int___isInteger (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___isZero" c_CasADi__Matrix_int___isZero :: Ptr IMatrix' -> IO CInt casADi__Matrix_int___isZero :: IMatrix -> IO Bool casADi__Matrix_int___isZero x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_int___isZero x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] check if the >matrix is 0 (note that false negative answers are possible) -} imatrix_isZero :: IMatrixClass a => a -> IO Bool imatrix_isZero x = casADi__Matrix_int___isZero (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___isOne" c_CasADi__Matrix_int___isOne :: Ptr IMatrix' -> IO CInt casADi__Matrix_int___isOne :: IMatrix -> IO Bool casADi__Matrix_int___isOne x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_int___isOne x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] check if the >matrix is 1 (note that false negative answers are possible) -} imatrix_isOne :: IMatrixClass a => a -> IO Bool imatrix_isOne x = casADi__Matrix_int___isOne (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___isMinusOne" c_CasADi__Matrix_int___isMinusOne :: Ptr IMatrix' -> IO CInt casADi__Matrix_int___isMinusOne :: IMatrix -> IO Bool casADi__Matrix_int___isMinusOne x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_int___isMinusOne x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] check if the >matrix is -1 (note that false negative answers are possible) -} imatrix_isMinusOne :: IMatrixClass a => a -> IO Bool imatrix_isMinusOne x = casADi__Matrix_int___isMinusOne (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___isIdentity" c_CasADi__Matrix_int___isIdentity :: Ptr IMatrix' -> IO CInt casADi__Matrix_int___isIdentity :: IMatrix -> IO Bool casADi__Matrix_int___isIdentity x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_int___isIdentity x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] check if the >matrix is an identity matrix (note that false negative answers are possible) -} imatrix_isIdentity :: IMatrixClass a => a -> IO Bool imatrix_isIdentity x = casADi__Matrix_int___isIdentity (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___isEqual" c_CasADi__Matrix_int___isEqual :: Ptr IMatrix' -> Ptr IMatrix' -> IO CInt casADi__Matrix_int___isEqual :: IMatrix -> IMatrix -> IO Bool casADi__Matrix_int___isEqual x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_int___isEqual x0' x1' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Check if two >expressions are equal May give false negatives. > >Note: does not work when CasadiOptions.setSimplificationOnTheFly(False) was >called -} imatrix_isEqual :: IMatrixClass a => a -> IMatrix -> IO Bool imatrix_isEqual x = casADi__Matrix_int___isEqual (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___hasNonStructuralZeros" c_CasADi__Matrix_int___hasNonStructuralZeros :: Ptr IMatrix' -> IO CInt casADi__Matrix_int___hasNonStructuralZeros :: IMatrix -> IO Bool casADi__Matrix_int___hasNonStructuralZeros x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_int___hasNonStructuralZeros x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] >Check if the matrix has any zero entries which are not structural zeros. -} imatrix_hasNonStructuralZeros :: IMatrixClass a => a -> IO Bool imatrix_hasNonStructuralZeros x = casADi__Matrix_int___hasNonStructuralZeros (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___getValue" c_CasADi__Matrix_int___getValue :: Ptr IMatrix' -> IO CDouble casADi__Matrix_int___getValue :: IMatrix -> IO Double casADi__Matrix_int___getValue x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_int___getValue x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Get double >value (only if constant) -} imatrix_getValue :: IMatrixClass a => a -> IO Double imatrix_getValue x = casADi__Matrix_int___getValue (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___getName" c_CasADi__Matrix_int___getName :: Ptr IMatrix' -> IO (Ptr StdString') casADi__Matrix_int___getName :: IMatrix -> IO String casADi__Matrix_int___getName x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_int___getName x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Get name (only >if symbolic scalar) -} imatrix_getName :: IMatrixClass a => a -> IO String imatrix_getName x = casADi__Matrix_int___getName (castIMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___setPrecision" c_CasADi__Matrix_int___setPrecision :: CInt -> IO () casADi__Matrix_int___setPrecision :: Int -> IO () casADi__Matrix_int___setPrecision x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_int___setPrecision x0' >>= wrapReturn -- classy wrapper {-| >Set the 'precision, width & scientific' used in printing and serializing to >streams. -} imatrix_setPrecision :: Int -> IO () imatrix_setPrecision = casADi__Matrix_int___setPrecision -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___setWidth" c_CasADi__Matrix_int___setWidth :: CInt -> IO () casADi__Matrix_int___setWidth :: Int -> IO () casADi__Matrix_int___setWidth x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_int___setWidth x0' >>= wrapReturn -- classy wrapper {-| >Set the 'precision, width & scientific' used in printing and serializing to >streams. -} imatrix_setWidth :: Int -> IO () imatrix_setWidth = casADi__Matrix_int___setWidth -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___setScientific" c_CasADi__Matrix_int___setScientific :: CInt -> IO () casADi__Matrix_int___setScientific :: Bool -> IO () casADi__Matrix_int___setScientific x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_int___setScientific x0' >>= wrapReturn -- classy wrapper {-| >Set the 'precision, width & scientific' used in printing and serializing to >streams. -} imatrix_setScientific :: Bool -> IO () imatrix_setScientific = casADi__Matrix_int___setScientific -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___IMatrix" c_CasADi__Matrix_int___IMatrix :: IO (Ptr IMatrix') casADi__Matrix_int___IMatrix :: IO IMatrix casADi__Matrix_int___IMatrix = c_CasADi__Matrix_int___IMatrix >>= wrapReturn -- classy wrapper {-| >> CasADi::Matrix< DataType >::Matrix(int nrow, int ncol) > >> CasADi::Matrix< DataType >::Matrix(int nrow, int ncol, const DataType &val) > >> CasADi::Matrix< DataType >::Matrix(int nrow, int ncol, const std::vector< int > &colind, const std::vector< int > &row, const std::vector< DataType > &d=std::vector< DataType >()) >------------------------------------------------------------------------ > >[DEPRECATED] > >> CasADi::Matrix< DataType >::Matrix(const Sparsity &sparsity, const DataType &val=DataType(0)) >------------------------------------------------------------------------ >[INTERNAL] >Sparse matrix with a given sparsity. > >> CasADi::Matrix< DataType >::Matrix() >------------------------------------------------------------------------ >[INTERNAL] >constructors > >empty 0-by-0 matrix constructor > >> CasADi::Matrix< DataType >::Matrix(const Matrix< DataType > &m) >------------------------------------------------------------------------ >[INTERNAL] >Copy constructor. > >> CasADi::Matrix< DataType >::Matrix(const std::vector< std::vector< DataType > > &m) >------------------------------------------------------------------------ >[INTERNAL] >Dense matrix constructor with data given as vector of vectors. > >> CasADi::Matrix< DataType >::Matrix(const Sparsity &sparsity, const std::vector< DataType > &d) >------------------------------------------------------------------------ >[INTERNAL] >Sparse matrix with a given sparsity and non-zero elements. > >> CasADi::Matrix< DataType >::Matrix(double val) >------------------------------------------------------------------------ >[INTERNAL] >This constructor enables implicit type conversion from a numeric type. > >> CasADi::Matrix< DataType >::Matrix(const std::vector< DataType > &x) >------------------------------------------------------------------------ >[INTERNAL] >Construct from a vector. > >Thanks to implicit conversion, you can pretend that Matrix(const SXElement& >x); exists. Note: above remark applies only to C++, not python or octave >interfaces > >> CasADi::Matrix< DataType >::Matrix(const std::vector< DataType > &x, int nrow, int ncol) >------------------------------------------------------------------------ >[INTERNAL] >Construct dense matrix from a vector with the elements in column major >ordering. > >> CasADi::Matrix< T >::Matrix(const Matrix< A > &x) >------------------------------------------------------------------------ > >Create a matrix from a matrix with a different type of matrix entries >(assuming that the scalar conversion is valid) > >> CasADi::Matrix< T >::Matrix(const std::vector< A > &x) >------------------------------------------------------------------------ > >Create an expression from an stl vector. > >> CasADi::Matrix< T >::Matrix(const std::vector< A > &x, int nrow, int ncol) >------------------------------------------------------------------------ > >Create a non-vector expression from an stl vector. -} imatrix :: IO IMatrix imatrix = casADi__Matrix_int___IMatrix -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___IMatrix_TIC" c_CasADi__Matrix_int___IMatrix_TIC :: Ptr IMatrix' -> IO (Ptr IMatrix') casADi__Matrix_int___IMatrix' :: IMatrix -> IO IMatrix casADi__Matrix_int___IMatrix' x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_int___IMatrix_TIC x0' >>= wrapReturn -- classy wrapper imatrix' :: IMatrix -> IO IMatrix imatrix' = casADi__Matrix_int___IMatrix' -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___IMatrix_TIC_TIC" c_CasADi__Matrix_int___IMatrix_TIC_TIC :: Ptr (CppVec (Ptr (CppVec CInt))) -> IO (Ptr IMatrix') casADi__Matrix_int___IMatrix'' :: Vector (Vector Int) -> IO IMatrix casADi__Matrix_int___IMatrix'' x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_int___IMatrix_TIC_TIC x0' >>= wrapReturn -- classy wrapper imatrix'' :: Vector (Vector Int) -> IO IMatrix imatrix'' = casADi__Matrix_int___IMatrix'' -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___IMatrix_TIC_TIC_TIC" c_CasADi__Matrix_int___IMatrix_TIC_TIC_TIC :: Ptr Sparsity' -> CInt -> IO (Ptr IMatrix') casADi__Matrix_int___IMatrix''' :: Sparsity -> Int -> IO IMatrix casADi__Matrix_int___IMatrix''' x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_int___IMatrix_TIC_TIC_TIC x0' x1' >>= wrapReturn -- classy wrapper imatrix''' :: Sparsity -> Int -> IO IMatrix imatrix''' = casADi__Matrix_int___IMatrix''' -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___IMatrix_TIC_TIC_TIC_TIC" c_CasADi__Matrix_int___IMatrix_TIC_TIC_TIC_TIC :: Ptr Sparsity' -> IO (Ptr IMatrix') casADi__Matrix_int___IMatrix'''' :: Sparsity -> IO IMatrix casADi__Matrix_int___IMatrix'''' x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_int___IMatrix_TIC_TIC_TIC_TIC x0' >>= wrapReturn -- classy wrapper imatrix'''' :: Sparsity -> IO IMatrix imatrix'''' = casADi__Matrix_int___IMatrix'''' -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___IMatrix_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_int___IMatrix_TIC_TIC_TIC_TIC_TIC :: Ptr Sparsity' -> Ptr (CppVec CInt) -> IO (Ptr IMatrix') casADi__Matrix_int___IMatrix''''' :: Sparsity -> Vector Int -> IO IMatrix casADi__Matrix_int___IMatrix''''' x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_int___IMatrix_TIC_TIC_TIC_TIC_TIC x0' x1' >>= wrapReturn -- classy wrapper imatrix''''' :: Sparsity -> Vector Int -> IO IMatrix imatrix''''' = casADi__Matrix_int___IMatrix''''' -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___IMatrix_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_int___IMatrix_TIC_TIC_TIC_TIC_TIC_TIC :: CDouble -> IO (Ptr IMatrix') casADi__Matrix_int___IMatrix'''''' :: Double -> IO IMatrix casADi__Matrix_int___IMatrix'''''' x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_int___IMatrix_TIC_TIC_TIC_TIC_TIC_TIC x0' >>= wrapReturn -- classy wrapper imatrix'''''' :: Double -> IO IMatrix imatrix'''''' = casADi__Matrix_int___IMatrix'''''' -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___IMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_int___IMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC :: Ptr (CppVec CInt) -> IO (Ptr IMatrix') casADi__Matrix_int___IMatrix''''''' :: Vector Int -> IO IMatrix casADi__Matrix_int___IMatrix''''''' x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_int___IMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' >>= wrapReturn -- classy wrapper imatrix''''''' :: Vector Int -> IO IMatrix imatrix''''''' = casADi__Matrix_int___IMatrix''''''' -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_int___IMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_int___IMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC :: Ptr (CppVec CInt) -> CInt -> CInt -> IO (Ptr IMatrix') casADi__Matrix_int___IMatrix'''''''' :: Vector Int -> Int -> Int -> IO IMatrix casADi__Matrix_int___IMatrix'''''''' x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_int___IMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' >>= wrapReturn -- classy wrapper imatrix'''''''' :: Vector Int -> Int -> Int -> IO IMatrix imatrix'''''''' = casADi__Matrix_int___IMatrix''''''''