{-# OPTIONS_GHC -Wall #-} {-# OPTIONS_GHC -fno-warn-unused-imports #-} {-# OPTIONS_GHC -fno-warn-orphans #-} {-# Language ForeignFunctionInterface #-} {-# Language FlexibleInstances #-} {-# Language MultiParamTypeClasses #-} module Casadi.Wrappers.Classes.DMatrix ( DMatrix, DMatrixClass(..), dmatrix, dmatrix', dmatrix'', dmatrix''', dmatrix'''', dmatrix''''', dmatrix'''''', dmatrix''''''', dmatrix'''''''', dmatrix''''''''', dmatrix'''''''''', dmatrix''''''''''', dmatrix___add__, dmatrix___constpow__, dmatrix___copysign__, dmatrix___div__, dmatrix___eq__, dmatrix___le__, dmatrix___lt__, dmatrix___mpower__, dmatrix___mrdivide__, dmatrix___mul__, dmatrix___ne__, dmatrix___nonzero__, dmatrix___pow__, dmatrix___sub__, dmatrix___truediv__, dmatrix_append, dmatrix_appendColumns, dmatrix_arccos, dmatrix_arccosh, dmatrix_arcsin, dmatrix_arcsinh, dmatrix_arctan, dmatrix_arctan2, dmatrix_arctanh, dmatrix_at, dmatrix_binary, dmatrix_ceil, dmatrix_className, dmatrix_clear, dmatrix_colind, dmatrix_cos, dmatrix_cosh, dmatrix_data, dmatrix_densify, dmatrix_densify', dmatrix_elem, dmatrix_elem', dmatrix_enlarge, dmatrix_erase, dmatrix_erf, dmatrix_erfinv, dmatrix_exp, dmatrix_eye, dmatrix_fabs, dmatrix_floor, dmatrix_fmax, dmatrix_fmin, dmatrix_get, dmatrix_get', dmatrix_get'', dmatrix_get''', dmatrix_get'''', dmatrix_get''''', dmatrix_getEqualityCheckingDepth, dmatrix_getMaxNumCallsInPrint, dmatrix_getName, dmatrix_getValue, dmatrix_hasNZ, dmatrix_hasNonStructuralZeros, dmatrix_if_else_zero, dmatrix_indexed_assignment, dmatrix_indexed_assignment', dmatrix_indexed_assignment'', dmatrix_indexed_assignment''', dmatrix_indexed_assignment'''', dmatrix_indexed_assignment''''', dmatrix_indexed_assignment'''''', dmatrix_indexed_assignment''''''', dmatrix_indexed_assignment'''''''', dmatrix_indexed_assignment''''''''', dmatrix_indexed_one_based_assignment, dmatrix_indexed_one_based_assignment', dmatrix_indexed_one_based_assignment'', dmatrix_indexed_zero_based_assignment, dmatrix_indexed_zero_based_assignment', dmatrix_indexed_zero_based_assignment'', dmatrix_inf, dmatrix_inf', dmatrix_inf'', dmatrix_inf''', dmatrix_isConstant, dmatrix_isEqual, dmatrix_isIdentity, dmatrix_isInteger, dmatrix_isMinusOne, dmatrix_isOne, dmatrix_isRegular, dmatrix_isSmooth, dmatrix_isSymbolic, dmatrix_isSymbolicSparse, dmatrix_isZero, dmatrix_log, dmatrix_log10, dmatrix_logic_and, dmatrix_logic_not, dmatrix_logic_or, dmatrix_matrix_matrix, dmatrix_matrix_scalar, dmatrix_mul, dmatrix_mul', dmatrix_mul_full, dmatrix_mul_full', dmatrix_mul_no_alloc_nn, dmatrix_mul_no_alloc_nn', dmatrix_mul_no_alloc_nt, dmatrix_mul_no_alloc_tn, dmatrix_mul_no_alloc_tn', dmatrix_nan, dmatrix_nan', dmatrix_nan'', dmatrix_nan''', dmatrix_nz_indexed_assignment, dmatrix_nz_indexed_assignment', dmatrix_nz_indexed_one_based_assignment, dmatrix_nz_indexed_one_based_assignment', dmatrix_nz_indexed_zero_based_assignment, dmatrix_nz_indexed_zero_based_assignment', dmatrix_operator_minus, dmatrix_operator_plus, dmatrix_printDense', dmatrix_printScalar', dmatrix_printSparse', dmatrix_printVector', dmatrix_printme, dmatrix_quad_form, dmatrix_remove, dmatrix_repmat, dmatrix_repmat', dmatrix_repmat'', dmatrix_repmat''', dmatrix_reserve, dmatrix_reserve', dmatrix_resize, dmatrix_row, dmatrix_sanityCheck, dmatrix_sanityCheck', dmatrix_scalar_matrix, dmatrix_set, dmatrix_set', dmatrix_set'', dmatrix_set''', dmatrix_set'''', dmatrix_set''''', dmatrix_setAll, dmatrix_setEqualityCheckingDepth, dmatrix_setEqualityCheckingDepth', dmatrix_setMaxNumCallsInPrint, dmatrix_setMaxNumCallsInPrint', dmatrix_setNZ, dmatrix_setNZ', dmatrix_setNZ'', dmatrix_setNZ''', dmatrix_setPrecision, dmatrix_setScientific, dmatrix_setSparse, dmatrix_setSparse', dmatrix_setSub, dmatrix_setSub', dmatrix_setSub'', dmatrix_setSub''', dmatrix_setSub'''', dmatrix_setSub''''', dmatrix_setSub'''''', dmatrix_setSub''''''', dmatrix_setSub'''''''', dmatrix_setSub''''''''', dmatrix_setSub'''''''''', dmatrix_setSub''''''''''', dmatrix_setSub'''''''''''', dmatrix_setSub''''''''''''', dmatrix_setWidth, dmatrix_setZero, dmatrix_sign, dmatrix_sin, dmatrix_sinh, dmatrix_sparsify, dmatrix_sparsify', dmatrix_sparsityRef, dmatrix_sqrt, dmatrix_tan, dmatrix_tanh, dmatrix_trans, dmatrix_triplet, dmatrix_triplet', dmatrix_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 DMatrix where show = unsafePerformIO . printableObject_getDescription -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___sanityCheck" c_CasADi__Matrix_double___sanityCheck :: Ptr DMatrix' -> CInt -> IO () casADi__Matrix_double___sanityCheck :: DMatrix -> Bool -> IO () casADi__Matrix_double___sanityCheck x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_double___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 -} dmatrix_sanityCheck :: DMatrixClass a => a -> Bool -> IO () dmatrix_sanityCheck x = casADi__Matrix_double___sanityCheck (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___sanityCheck_TIC" c_CasADi__Matrix_double___sanityCheck_TIC :: Ptr DMatrix' -> IO () casADi__Matrix_double___sanityCheck' :: DMatrix -> IO () casADi__Matrix_double___sanityCheck' x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_double___sanityCheck_TIC x0' >>= wrapReturn -- classy wrapper dmatrix_sanityCheck' :: DMatrixClass a => a -> IO () dmatrix_sanityCheck' x = casADi__Matrix_double___sanityCheck' (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___at" c_CasADi__Matrix_double___at :: Ptr DMatrix' -> CInt -> IO CDouble casADi__Matrix_double___at :: DMatrix -> Int -> IO Double casADi__Matrix_double___at x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_double___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. -} dmatrix_at :: DMatrixClass a => a -> Int -> IO Double dmatrix_at x = casADi__Matrix_double___at (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___elem" c_CasADi__Matrix_double___elem :: Ptr DMatrix' -> CInt -> CInt -> IO CDouble casADi__Matrix_double___elem :: DMatrix -> Int -> Int -> IO Double casADi__Matrix_double___elem x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_double___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 -} dmatrix_elem :: DMatrixClass a => a -> Int -> Int -> IO Double dmatrix_elem x = casADi__Matrix_double___elem (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___elem_TIC" c_CasADi__Matrix_double___elem_TIC :: Ptr DMatrix' -> CInt -> IO CDouble casADi__Matrix_double___elem' :: DMatrix -> Int -> IO Double casADi__Matrix_double___elem' x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_double___elem_TIC x0' x1' >>= wrapReturn -- classy wrapper dmatrix_elem' :: DMatrixClass a => a -> Int -> IO Double dmatrix_elem' x = casADi__Matrix_double___elem' (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___hasNZ" c_CasADi__Matrix_double___hasNZ :: Ptr DMatrix' -> CInt -> CInt -> IO CInt casADi__Matrix_double___hasNZ :: DMatrix -> Int -> Int -> IO Bool casADi__Matrix_double___hasNZ x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_double___hasNZ x0' x1' x2' >>= wrapReturn -- classy wrapper {-| >Returns true if the matrix has a non-zero at location rr,cc. -} dmatrix_hasNZ :: DMatrixClass a => a -> Int -> Int -> IO Bool dmatrix_hasNZ x = casADi__Matrix_double___hasNZ (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double_____nonzero__" c_CasADi__Matrix_double_____nonzero__ :: Ptr DMatrix' -> IO CInt casADi__Matrix_double_____nonzero__ :: DMatrix -> IO Bool casADi__Matrix_double_____nonzero__ x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_double_____nonzero__ x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Returns the >truth value of a Matrix. -} dmatrix___nonzero__ :: DMatrixClass a => a -> IO Bool dmatrix___nonzero__ x = casADi__Matrix_double_____nonzero__ (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___setSub" c_CasADi__Matrix_double___setSub :: Ptr DMatrix' -> Ptr DMatrix' -> CInt -> CInt -> IO () casADi__Matrix_double___setSub :: DMatrix -> DMatrix -> Int -> Int -> IO () casADi__Matrix_double___setSub x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> c_CasADi__Matrix_double___setSub x0' x1' x2' x3' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Set a submatrix. -} dmatrix_setSub :: DMatrixClass a => a -> DMatrix -> Int -> Int -> IO () dmatrix_setSub x = casADi__Matrix_double___setSub (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___setSub_TIC" c_CasADi__Matrix_double___setSub_TIC :: Ptr DMatrix' -> Ptr DMatrix' -> Ptr (CppVec CInt) -> CInt -> IO () casADi__Matrix_double___setSub' :: DMatrix -> DMatrix -> Vector Int -> Int -> IO () casADi__Matrix_double___setSub' x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> c_CasADi__Matrix_double___setSub_TIC x0' x1' x2' x3' >>= wrapReturn -- classy wrapper dmatrix_setSub' :: DMatrixClass a => a -> DMatrix -> Vector Int -> Int -> IO () dmatrix_setSub' x = casADi__Matrix_double___setSub' (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___setSub_TIC_TIC" c_CasADi__Matrix_double___setSub_TIC_TIC :: Ptr DMatrix' -> Ptr DMatrix' -> CInt -> Ptr (CppVec CInt) -> IO () casADi__Matrix_double___setSub'' :: DMatrix -> DMatrix -> Int -> Vector Int -> IO () casADi__Matrix_double___setSub'' x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> c_CasADi__Matrix_double___setSub_TIC_TIC x0' x1' x2' x3' >>= wrapReturn -- classy wrapper dmatrix_setSub'' :: DMatrixClass a => a -> DMatrix -> Int -> Vector Int -> IO () dmatrix_setSub'' x = casADi__Matrix_double___setSub'' (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___setSub_TIC_TIC_TIC" c_CasADi__Matrix_double___setSub_TIC_TIC_TIC :: Ptr DMatrix' -> Ptr DMatrix' -> Ptr (CppVec CInt) -> Ptr (CppVec CInt) -> IO () casADi__Matrix_double___setSub''' :: DMatrix -> DMatrix -> Vector Int -> Vector Int -> IO () casADi__Matrix_double___setSub''' x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> c_CasADi__Matrix_double___setSub_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn -- classy wrapper dmatrix_setSub''' :: DMatrixClass a => a -> DMatrix -> Vector Int -> Vector Int -> IO () dmatrix_setSub''' x = casADi__Matrix_double___setSub''' (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___setSub_TIC_TIC_TIC_TIC" c_CasADi__Matrix_double___setSub_TIC_TIC_TIC_TIC :: Ptr DMatrix' -> Ptr DMatrix' -> Ptr Slice' -> Ptr (CppVec CInt) -> IO () casADi__Matrix_double___setSub'''' :: DMatrix -> DMatrix -> Slice -> Vector Int -> IO () casADi__Matrix_double___setSub'''' x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> c_CasADi__Matrix_double___setSub_TIC_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn -- classy wrapper dmatrix_setSub'''' :: DMatrixClass a => a -> DMatrix -> Slice -> Vector Int -> IO () dmatrix_setSub'''' x = casADi__Matrix_double___setSub'''' (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___setSub_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_double___setSub_TIC_TIC_TIC_TIC_TIC :: Ptr DMatrix' -> Ptr DMatrix' -> Ptr (CppVec CInt) -> Ptr Slice' -> IO () casADi__Matrix_double___setSub''''' :: DMatrix -> DMatrix -> Vector Int -> Slice -> IO () casADi__Matrix_double___setSub''''' x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> c_CasADi__Matrix_double___setSub_TIC_TIC_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn -- classy wrapper dmatrix_setSub''''' :: DMatrixClass a => a -> DMatrix -> Vector Int -> Slice -> IO () dmatrix_setSub''''' x = casADi__Matrix_double___setSub''''' (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___setSub_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_double___setSub_TIC_TIC_TIC_TIC_TIC_TIC :: Ptr DMatrix' -> Ptr DMatrix' -> Ptr Slice' -> Ptr Slice' -> IO () casADi__Matrix_double___setSub'''''' :: DMatrix -> DMatrix -> Slice -> Slice -> IO () casADi__Matrix_double___setSub'''''' x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> c_CasADi__Matrix_double___setSub_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn -- classy wrapper dmatrix_setSub'''''' :: DMatrixClass a => a -> DMatrix -> Slice -> Slice -> IO () dmatrix_setSub'''''' x = casADi__Matrix_double___setSub'''''' (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_double___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC :: Ptr DMatrix' -> Ptr DMatrix' -> Ptr IMatrix' -> Ptr (CppVec CInt) -> IO () casADi__Matrix_double___setSub''''''' :: DMatrix -> DMatrix -> IMatrix -> Vector Int -> IO () casADi__Matrix_double___setSub''''''' x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> c_CasADi__Matrix_double___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn -- classy wrapper dmatrix_setSub''''''' :: DMatrixClass a => a -> DMatrix -> IMatrix -> Vector Int -> IO () dmatrix_setSub''''''' x = casADi__Matrix_double___setSub''''''' (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_double___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC :: Ptr DMatrix' -> Ptr DMatrix' -> Ptr (CppVec CInt) -> Ptr IMatrix' -> IO () casADi__Matrix_double___setSub'''''''' :: DMatrix -> DMatrix -> Vector Int -> IMatrix -> IO () casADi__Matrix_double___setSub'''''''' x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> c_CasADi__Matrix_double___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn -- classy wrapper dmatrix_setSub'''''''' :: DMatrixClass a => a -> DMatrix -> Vector Int -> IMatrix -> IO () dmatrix_setSub'''''''' x = casADi__Matrix_double___setSub'''''''' (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_double___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC :: Ptr DMatrix' -> Ptr DMatrix' -> Ptr IMatrix' -> Ptr Slice' -> IO () casADi__Matrix_double___setSub''''''''' :: DMatrix -> DMatrix -> IMatrix -> Slice -> IO () casADi__Matrix_double___setSub''''''''' x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> c_CasADi__Matrix_double___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn -- classy wrapper dmatrix_setSub''''''''' :: DMatrixClass a => a -> DMatrix -> IMatrix -> Slice -> IO () dmatrix_setSub''''''''' x = casADi__Matrix_double___setSub''''''''' (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_double___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC :: Ptr DMatrix' -> Ptr DMatrix' -> Ptr Slice' -> Ptr IMatrix' -> IO () casADi__Matrix_double___setSub'''''''''' :: DMatrix -> DMatrix -> Slice -> IMatrix -> IO () casADi__Matrix_double___setSub'''''''''' x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> c_CasADi__Matrix_double___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn -- classy wrapper dmatrix_setSub'''''''''' :: DMatrixClass a => a -> DMatrix -> Slice -> IMatrix -> IO () dmatrix_setSub'''''''''' x = casADi__Matrix_double___setSub'''''''''' (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_double___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC :: Ptr DMatrix' -> Ptr DMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> IO () casADi__Matrix_double___setSub''''''''''' :: DMatrix -> DMatrix -> IMatrix -> IMatrix -> IO () casADi__Matrix_double___setSub''''''''''' x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> c_CasADi__Matrix_double___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn -- classy wrapper dmatrix_setSub''''''''''' :: DMatrixClass a => a -> DMatrix -> IMatrix -> IMatrix -> IO () dmatrix_setSub''''''''''' x = casADi__Matrix_double___setSub''''''''''' (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_double___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC :: Ptr DMatrix' -> Ptr DMatrix' -> Ptr Slice' -> CInt -> IO () casADi__Matrix_double___setSub'''''''''''' :: DMatrix -> DMatrix -> Slice -> Int -> IO () casADi__Matrix_double___setSub'''''''''''' x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> c_CasADi__Matrix_double___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn -- classy wrapper dmatrix_setSub'''''''''''' :: DMatrixClass a => a -> DMatrix -> Slice -> Int -> IO () dmatrix_setSub'''''''''''' x = casADi__Matrix_double___setSub'''''''''''' (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_double___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC :: Ptr DMatrix' -> Ptr DMatrix' -> Ptr Sparsity' -> CInt -> IO () casADi__Matrix_double___setSub''''''''''''' :: DMatrix -> DMatrix -> Sparsity -> Int -> IO () casADi__Matrix_double___setSub''''''''''''' x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> c_CasADi__Matrix_double___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn -- classy wrapper dmatrix_setSub''''''''''''' :: DMatrixClass a => a -> DMatrix -> Sparsity -> Int -> IO () dmatrix_setSub''''''''''''' x = casADi__Matrix_double___setSub''''''''''''' (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___setNZ" c_CasADi__Matrix_double___setNZ :: Ptr DMatrix' -> CInt -> Ptr DMatrix' -> IO () casADi__Matrix_double___setNZ :: DMatrix -> Int -> DMatrix -> IO () casADi__Matrix_double___setNZ x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_double___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. -} dmatrix_setNZ :: DMatrixClass a => a -> Int -> DMatrix -> IO () dmatrix_setNZ x = casADi__Matrix_double___setNZ (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___setNZ_TIC" c_CasADi__Matrix_double___setNZ_TIC :: Ptr DMatrix' -> Ptr (CppVec CInt) -> Ptr DMatrix' -> IO () casADi__Matrix_double___setNZ' :: DMatrix -> Vector Int -> DMatrix -> IO () casADi__Matrix_double___setNZ' x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_double___setNZ_TIC x0' x1' x2' >>= wrapReturn -- classy wrapper dmatrix_setNZ' :: DMatrixClass a => a -> Vector Int -> DMatrix -> IO () dmatrix_setNZ' x = casADi__Matrix_double___setNZ' (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___setNZ_TIC_TIC" c_CasADi__Matrix_double___setNZ_TIC_TIC :: Ptr DMatrix' -> Ptr Slice' -> Ptr DMatrix' -> IO () casADi__Matrix_double___setNZ'' :: DMatrix -> Slice -> DMatrix -> IO () casADi__Matrix_double___setNZ'' x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_double___setNZ_TIC_TIC x0' x1' x2' >>= wrapReturn -- classy wrapper dmatrix_setNZ'' :: DMatrixClass a => a -> Slice -> DMatrix -> IO () dmatrix_setNZ'' x = casADi__Matrix_double___setNZ'' (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___setNZ_TIC_TIC_TIC" c_CasADi__Matrix_double___setNZ_TIC_TIC_TIC :: Ptr DMatrix' -> Ptr IMatrix' -> Ptr DMatrix' -> IO () casADi__Matrix_double___setNZ''' :: DMatrix -> IMatrix -> DMatrix -> IO () casADi__Matrix_double___setNZ''' x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_double___setNZ_TIC_TIC_TIC x0' x1' x2' >>= wrapReturn -- classy wrapper dmatrix_setNZ''' :: DMatrixClass a => a -> IMatrix -> DMatrix -> IO () dmatrix_setNZ''' x = casADi__Matrix_double___setNZ''' (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___append" c_CasADi__Matrix_double___append :: Ptr DMatrix' -> Ptr DMatrix' -> IO () casADi__Matrix_double___append :: DMatrix -> DMatrix -> IO () casADi__Matrix_double___append x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_double___append x0' x1' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Append a matrix >vertically (NOTE: only efficient if vector) -} dmatrix_append :: DMatrixClass a => a -> DMatrix -> IO () dmatrix_append x = casADi__Matrix_double___append (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___appendColumns" c_CasADi__Matrix_double___appendColumns :: Ptr DMatrix' -> Ptr DMatrix' -> IO () casADi__Matrix_double___appendColumns :: DMatrix -> DMatrix -> IO () casADi__Matrix_double___appendColumns x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_double___appendColumns x0' x1' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Append a >matrix horizontally. -} dmatrix_appendColumns :: DMatrixClass a => a -> DMatrix -> IO () dmatrix_appendColumns x = casADi__Matrix_double___appendColumns (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___nz_indexed_one_based_assignment" c_CasADi__Matrix_double___nz_indexed_one_based_assignment :: Ptr DMatrix' -> CInt -> CDouble -> IO () casADi__Matrix_double___nz_indexed_one_based_assignment :: DMatrix -> Int -> Double -> IO () casADi__Matrix_double___nz_indexed_one_based_assignment x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_double___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 -} dmatrix_nz_indexed_one_based_assignment :: DMatrixClass a => a -> Int -> Double -> IO () dmatrix_nz_indexed_one_based_assignment x = casADi__Matrix_double___nz_indexed_one_based_assignment (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___nz_indexed_zero_based_assignment" c_CasADi__Matrix_double___nz_indexed_zero_based_assignment :: Ptr DMatrix' -> CInt -> CDouble -> IO () casADi__Matrix_double___nz_indexed_zero_based_assignment :: DMatrix -> Int -> Double -> IO () casADi__Matrix_double___nz_indexed_zero_based_assignment x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_double___nz_indexed_zero_based_assignment x0' x1' x2' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Indexing for interfaced languages get a non-zero -} dmatrix_nz_indexed_zero_based_assignment :: DMatrixClass a => a -> Int -> Double -> IO () dmatrix_nz_indexed_zero_based_assignment x = casADi__Matrix_double___nz_indexed_zero_based_assignment (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___nz_indexed_assignment" c_CasADi__Matrix_double___nz_indexed_assignment :: Ptr DMatrix' -> Ptr Slice' -> Ptr DMatrix' -> IO () casADi__Matrix_double___nz_indexed_assignment :: DMatrix -> Slice -> DMatrix -> IO () casADi__Matrix_double___nz_indexed_assignment x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_double___nz_indexed_assignment x0' x1' x2' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] >Indexing for interfaced languages get a non-zero -} dmatrix_nz_indexed_assignment :: DMatrixClass a => a -> Slice -> DMatrix -> IO () dmatrix_nz_indexed_assignment x = casADi__Matrix_double___nz_indexed_assignment (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___indexed_one_based_assignment" c_CasADi__Matrix_double___indexed_one_based_assignment :: Ptr DMatrix' -> Ptr IMatrix' -> Ptr DMatrix' -> IO () casADi__Matrix_double___indexed_one_based_assignment :: DMatrix -> IMatrix -> DMatrix -> IO () casADi__Matrix_double___indexed_one_based_assignment x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_double___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 -} dmatrix_indexed_one_based_assignment :: DMatrixClass a => a -> IMatrix -> DMatrix -> IO () dmatrix_indexed_one_based_assignment x = casADi__Matrix_double___indexed_one_based_assignment (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___indexed_zero_based_assignment" c_CasADi__Matrix_double___indexed_zero_based_assignment :: Ptr DMatrix' -> Ptr IMatrix' -> Ptr DMatrix' -> IO () casADi__Matrix_double___indexed_zero_based_assignment :: DMatrix -> IMatrix -> DMatrix -> IO () casADi__Matrix_double___indexed_zero_based_assignment x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_double___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] -} dmatrix_indexed_zero_based_assignment :: DMatrixClass a => a -> IMatrix -> DMatrix -> IO () dmatrix_indexed_zero_based_assignment x = casADi__Matrix_double___indexed_zero_based_assignment (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___nz_indexed_one_based_assignment_TIC" c_CasADi__Matrix_double___nz_indexed_one_based_assignment_TIC :: Ptr DMatrix' -> Ptr IMatrix' -> Ptr DMatrix' -> IO () casADi__Matrix_double___nz_indexed_one_based_assignment' :: DMatrix -> IMatrix -> DMatrix -> IO () casADi__Matrix_double___nz_indexed_one_based_assignment' x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_double___nz_indexed_one_based_assignment_TIC x0' x1' x2' >>= wrapReturn -- classy wrapper dmatrix_nz_indexed_one_based_assignment' :: DMatrixClass a => a -> IMatrix -> DMatrix -> IO () dmatrix_nz_indexed_one_based_assignment' x = casADi__Matrix_double___nz_indexed_one_based_assignment' (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___nz_indexed_zero_based_assignment_TIC" c_CasADi__Matrix_double___nz_indexed_zero_based_assignment_TIC :: Ptr DMatrix' -> Ptr IMatrix' -> Ptr DMatrix' -> IO () casADi__Matrix_double___nz_indexed_zero_based_assignment' :: DMatrix -> IMatrix -> DMatrix -> IO () casADi__Matrix_double___nz_indexed_zero_based_assignment' x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_double___nz_indexed_zero_based_assignment_TIC x0' x1' x2' >>= wrapReturn -- classy wrapper dmatrix_nz_indexed_zero_based_assignment' :: DMatrixClass a => a -> IMatrix -> DMatrix -> IO () dmatrix_nz_indexed_zero_based_assignment' x = casADi__Matrix_double___nz_indexed_zero_based_assignment' (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___nz_indexed_assignment_TIC" c_CasADi__Matrix_double___nz_indexed_assignment_TIC :: Ptr DMatrix' -> Ptr IndexList' -> Ptr DMatrix' -> IO () casADi__Matrix_double___nz_indexed_assignment' :: DMatrix -> IndexList -> DMatrix -> IO () casADi__Matrix_double___nz_indexed_assignment' x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_double___nz_indexed_assignment_TIC x0' x1' x2' >>= wrapReturn -- classy wrapper dmatrix_nz_indexed_assignment' :: DMatrixClass a => a -> IndexList -> DMatrix -> IO () dmatrix_nz_indexed_assignment' x = casADi__Matrix_double___nz_indexed_assignment' (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___indexed_one_based_assignment_TIC" c_CasADi__Matrix_double___indexed_one_based_assignment_TIC :: Ptr DMatrix' -> CInt -> CInt -> CDouble -> IO () casADi__Matrix_double___indexed_one_based_assignment' :: DMatrix -> Int -> Int -> Double -> IO () casADi__Matrix_double___indexed_one_based_assignment' x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> c_CasADi__Matrix_double___indexed_one_based_assignment_TIC x0' x1' x2' x3' >>= wrapReturn -- classy wrapper dmatrix_indexed_one_based_assignment' :: DMatrixClass a => a -> Int -> Int -> Double -> IO () dmatrix_indexed_one_based_assignment' x = casADi__Matrix_double___indexed_one_based_assignment' (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___indexed_zero_based_assignment_TIC" c_CasADi__Matrix_double___indexed_zero_based_assignment_TIC :: Ptr DMatrix' -> CInt -> CInt -> CDouble -> IO () casADi__Matrix_double___indexed_zero_based_assignment' :: DMatrix -> Int -> Int -> Double -> IO () casADi__Matrix_double___indexed_zero_based_assignment' x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> c_CasADi__Matrix_double___indexed_zero_based_assignment_TIC x0' x1' x2' x3' >>= wrapReturn -- classy wrapper dmatrix_indexed_zero_based_assignment' :: DMatrixClass a => a -> Int -> Int -> Double -> IO () dmatrix_indexed_zero_based_assignment' x = casADi__Matrix_double___indexed_zero_based_assignment' (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___indexed_assignment" c_CasADi__Matrix_double___indexed_assignment :: Ptr DMatrix' -> Ptr Slice' -> Ptr Slice' -> Ptr DMatrix' -> IO () casADi__Matrix_double___indexed_assignment :: DMatrix -> Slice -> Slice -> DMatrix -> IO () casADi__Matrix_double___indexed_assignment x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> c_CasADi__Matrix_double___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] -} dmatrix_indexed_assignment :: DMatrixClass a => a -> Slice -> Slice -> DMatrix -> IO () dmatrix_indexed_assignment x = casADi__Matrix_double___indexed_assignment (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___indexed_assignment_TIC" c_CasADi__Matrix_double___indexed_assignment_TIC :: Ptr DMatrix' -> Ptr IndexList' -> Ptr IndexList' -> Ptr DMatrix' -> IO () casADi__Matrix_double___indexed_assignment' :: DMatrix -> IndexList -> IndexList -> DMatrix -> IO () casADi__Matrix_double___indexed_assignment' x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> c_CasADi__Matrix_double___indexed_assignment_TIC x0' x1' x2' x3' >>= wrapReturn -- classy wrapper dmatrix_indexed_assignment' :: DMatrixClass a => a -> IndexList -> IndexList -> DMatrix -> IO () dmatrix_indexed_assignment' x = casADi__Matrix_double___indexed_assignment' (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___indexed_assignment_TIC_TIC" c_CasADi__Matrix_double___indexed_assignment_TIC_TIC :: Ptr DMatrix' -> Ptr Slice' -> Ptr IMatrix' -> Ptr DMatrix' -> IO () casADi__Matrix_double___indexed_assignment'' :: DMatrix -> Slice -> IMatrix -> DMatrix -> IO () casADi__Matrix_double___indexed_assignment'' x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> c_CasADi__Matrix_double___indexed_assignment_TIC_TIC x0' x1' x2' x3' >>= wrapReturn -- classy wrapper dmatrix_indexed_assignment'' :: DMatrixClass a => a -> Slice -> IMatrix -> DMatrix -> IO () dmatrix_indexed_assignment'' x = casADi__Matrix_double___indexed_assignment'' (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___indexed_assignment_TIC_TIC_TIC" c_CasADi__Matrix_double___indexed_assignment_TIC_TIC_TIC :: Ptr DMatrix' -> Ptr IMatrix' -> Ptr Slice' -> Ptr DMatrix' -> IO () casADi__Matrix_double___indexed_assignment''' :: DMatrix -> IMatrix -> Slice -> DMatrix -> IO () casADi__Matrix_double___indexed_assignment''' x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> c_CasADi__Matrix_double___indexed_assignment_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn -- classy wrapper dmatrix_indexed_assignment''' :: DMatrixClass a => a -> IMatrix -> Slice -> DMatrix -> IO () dmatrix_indexed_assignment''' x = casADi__Matrix_double___indexed_assignment''' (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___indexed_assignment_TIC_TIC_TIC_TIC" c_CasADi__Matrix_double___indexed_assignment_TIC_TIC_TIC_TIC :: Ptr DMatrix' -> Ptr IMatrix' -> Ptr IndexList' -> Ptr DMatrix' -> IO () casADi__Matrix_double___indexed_assignment'''' :: DMatrix -> IMatrix -> IndexList -> DMatrix -> IO () casADi__Matrix_double___indexed_assignment'''' x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> c_CasADi__Matrix_double___indexed_assignment_TIC_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn -- classy wrapper dmatrix_indexed_assignment'''' :: DMatrixClass a => a -> IMatrix -> IndexList -> DMatrix -> IO () dmatrix_indexed_assignment'''' x = casADi__Matrix_double___indexed_assignment'''' (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___indexed_assignment_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_double___indexed_assignment_TIC_TIC_TIC_TIC_TIC :: Ptr DMatrix' -> Ptr IndexList' -> Ptr IMatrix' -> Ptr DMatrix' -> IO () casADi__Matrix_double___indexed_assignment''''' :: DMatrix -> IndexList -> IMatrix -> DMatrix -> IO () casADi__Matrix_double___indexed_assignment''''' x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> c_CasADi__Matrix_double___indexed_assignment_TIC_TIC_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn -- classy wrapper dmatrix_indexed_assignment''''' :: DMatrixClass a => a -> IndexList -> IMatrix -> DMatrix -> IO () dmatrix_indexed_assignment''''' x = casADi__Matrix_double___indexed_assignment''''' (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_double___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC :: Ptr DMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr DMatrix' -> IO () casADi__Matrix_double___indexed_assignment'''''' :: DMatrix -> IMatrix -> IMatrix -> DMatrix -> IO () casADi__Matrix_double___indexed_assignment'''''' x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> c_CasADi__Matrix_double___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn -- classy wrapper dmatrix_indexed_assignment'''''' :: DMatrixClass a => a -> IMatrix -> IMatrix -> DMatrix -> IO () dmatrix_indexed_assignment'''''' x = casADi__Matrix_double___indexed_assignment'''''' (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_double___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC :: Ptr DMatrix' -> Ptr Sparsity' -> Ptr DMatrix' -> IO () casADi__Matrix_double___indexed_assignment''''''' :: DMatrix -> Sparsity -> DMatrix -> IO () casADi__Matrix_double___indexed_assignment''''''' x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_double___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' >>= wrapReturn -- classy wrapper dmatrix_indexed_assignment''''''' :: DMatrixClass a => a -> Sparsity -> DMatrix -> IO () dmatrix_indexed_assignment''''''' x = casADi__Matrix_double___indexed_assignment''''''' (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___indexed_one_based_assignment_TIC_TIC" c_CasADi__Matrix_double___indexed_one_based_assignment_TIC_TIC :: Ptr DMatrix' -> CInt -> CDouble -> IO () casADi__Matrix_double___indexed_one_based_assignment'' :: DMatrix -> Int -> Double -> IO () casADi__Matrix_double___indexed_one_based_assignment'' x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_double___indexed_one_based_assignment_TIC_TIC x0' x1' x2' >>= wrapReturn -- classy wrapper dmatrix_indexed_one_based_assignment'' :: DMatrixClass a => a -> Int -> Double -> IO () dmatrix_indexed_one_based_assignment'' x = casADi__Matrix_double___indexed_one_based_assignment'' (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___indexed_zero_based_assignment_TIC_TIC" c_CasADi__Matrix_double___indexed_zero_based_assignment_TIC_TIC :: Ptr DMatrix' -> CInt -> CDouble -> IO () casADi__Matrix_double___indexed_zero_based_assignment'' :: DMatrix -> Int -> Double -> IO () casADi__Matrix_double___indexed_zero_based_assignment'' x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_double___indexed_zero_based_assignment_TIC_TIC x0' x1' x2' >>= wrapReturn -- classy wrapper dmatrix_indexed_zero_based_assignment'' :: DMatrixClass a => a -> Int -> Double -> IO () dmatrix_indexed_zero_based_assignment'' x = casADi__Matrix_double___indexed_zero_based_assignment'' (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_double___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC :: Ptr DMatrix' -> Ptr Slice' -> Ptr DMatrix' -> IO () casADi__Matrix_double___indexed_assignment'''''''' :: DMatrix -> Slice -> DMatrix -> IO () casADi__Matrix_double___indexed_assignment'''''''' x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_double___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' >>= wrapReturn -- classy wrapper dmatrix_indexed_assignment'''''''' :: DMatrixClass a => a -> Slice -> DMatrix -> IO () dmatrix_indexed_assignment'''''''' x = casADi__Matrix_double___indexed_assignment'''''''' (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_double___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC :: Ptr DMatrix' -> Ptr IndexList' -> Ptr DMatrix' -> IO () casADi__Matrix_double___indexed_assignment''''''''' :: DMatrix -> IndexList -> DMatrix -> IO () casADi__Matrix_double___indexed_assignment''''''''' x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_double___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' >>= wrapReturn -- classy wrapper dmatrix_indexed_assignment''''''''' :: DMatrixClass a => a -> IndexList -> DMatrix -> IO () dmatrix_indexed_assignment''''''''' x = casADi__Matrix_double___indexed_assignment''''''''' (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___setZero" c_CasADi__Matrix_double___setZero :: Ptr DMatrix' -> IO () casADi__Matrix_double___setZero :: DMatrix -> IO () casADi__Matrix_double___setZero x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_double___setZero x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Set all elements >to zero. -} dmatrix_setZero :: DMatrixClass a => a -> IO () dmatrix_setZero x = casADi__Matrix_double___setZero (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___setAll" c_CasADi__Matrix_double___setAll :: Ptr DMatrix' -> CDouble -> IO () casADi__Matrix_double___setAll :: DMatrix -> Double -> IO () casADi__Matrix_double___setAll x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_double___setAll x0' x1' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Set all elements >to a value. -} dmatrix_setAll :: DMatrixClass a => a -> Double -> IO () dmatrix_setAll x = casADi__Matrix_double___setAll (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___setSparse" c_CasADi__Matrix_double___setSparse :: Ptr DMatrix' -> Ptr Sparsity' -> CInt -> IO (Ptr DMatrix') casADi__Matrix_double___setSparse :: DMatrix -> Sparsity -> Bool -> IO DMatrix casADi__Matrix_double___setSparse x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_double___setSparse x0' x1' x2' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Set sparse. -} dmatrix_setSparse :: DMatrixClass a => a -> Sparsity -> Bool -> IO DMatrix dmatrix_setSparse x = casADi__Matrix_double___setSparse (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___setSparse_TIC" c_CasADi__Matrix_double___setSparse_TIC :: Ptr DMatrix' -> Ptr Sparsity' -> IO (Ptr DMatrix') casADi__Matrix_double___setSparse' :: DMatrix -> Sparsity -> IO DMatrix casADi__Matrix_double___setSparse' x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_double___setSparse_TIC x0' x1' >>= wrapReturn -- classy wrapper dmatrix_setSparse' :: DMatrixClass a => a -> Sparsity -> IO DMatrix dmatrix_setSparse' x = casADi__Matrix_double___setSparse' (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___densify" c_CasADi__Matrix_double___densify :: Ptr DMatrix' -> CDouble -> IO () casADi__Matrix_double___densify :: DMatrix -> Double -> IO () casADi__Matrix_double___densify x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_double___densify x0' x1' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Make the matrix >dense. -} dmatrix_densify :: DMatrixClass a => a -> Double -> IO () dmatrix_densify x = casADi__Matrix_double___densify (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___densify_TIC" c_CasADi__Matrix_double___densify_TIC :: Ptr DMatrix' -> IO () casADi__Matrix_double___densify' :: DMatrix -> IO () casADi__Matrix_double___densify' x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_double___densify_TIC x0' >>= wrapReturn -- classy wrapper dmatrix_densify' :: DMatrixClass a => a -> IO () dmatrix_densify' x = casADi__Matrix_double___densify' (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___sparsify" c_CasADi__Matrix_double___sparsify :: Ptr DMatrix' -> CDouble -> IO () casADi__Matrix_double___sparsify :: DMatrix -> Double -> IO () casADi__Matrix_double___sparsify x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_double___sparsify x0' x1' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Make a matrix >sparse by removing numerical zeros smaller in absolute value than a >specified tolerance. -} dmatrix_sparsify :: DMatrixClass a => a -> Double -> IO () dmatrix_sparsify x = casADi__Matrix_double___sparsify (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___sparsify_TIC" c_CasADi__Matrix_double___sparsify_TIC :: Ptr DMatrix' -> IO () casADi__Matrix_double___sparsify' :: DMatrix -> IO () casADi__Matrix_double___sparsify' x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_double___sparsify_TIC x0' >>= wrapReturn -- classy wrapper dmatrix_sparsify' :: DMatrixClass a => a -> IO () dmatrix_sparsify' x = casADi__Matrix_double___sparsify' (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___operator_plus" c_CasADi__Matrix_double___operator_plus :: Ptr DMatrix' -> IO (Ptr DMatrix') casADi__Matrix_double___operator_plus :: DMatrix -> IO DMatrix casADi__Matrix_double___operator_plus x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_double___operator_plus x0' >>= wrapReturn -- classy wrapper dmatrix_operator_plus :: DMatrixClass a => a -> IO DMatrix dmatrix_operator_plus x = casADi__Matrix_double___operator_plus (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___operator_minus" c_CasADi__Matrix_double___operator_minus :: Ptr DMatrix' -> IO (Ptr DMatrix') casADi__Matrix_double___operator_minus :: DMatrix -> IO DMatrix casADi__Matrix_double___operator_minus x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_double___operator_minus x0' >>= wrapReturn -- classy wrapper dmatrix_operator_minus :: DMatrixClass a => a -> IO DMatrix dmatrix_operator_minus x = casADi__Matrix_double___operator_minus (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___binary" c_CasADi__Matrix_double___binary :: CInt -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') casADi__Matrix_double___binary :: Int -> DMatrix -> DMatrix -> IO DMatrix casADi__Matrix_double___binary x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_double___binary x0' x1' x2' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Create nodes by >their ID. -} dmatrix_binary :: Int -> DMatrix -> DMatrix -> IO DMatrix dmatrix_binary = casADi__Matrix_double___binary -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___unary" c_CasADi__Matrix_double___unary :: CInt -> Ptr DMatrix' -> IO (Ptr DMatrix') casADi__Matrix_double___unary :: Int -> DMatrix -> IO DMatrix casADi__Matrix_double___unary x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_double___unary x0' x1' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Create nodes by >their ID. -} dmatrix_unary :: Int -> DMatrix -> IO DMatrix dmatrix_unary = casADi__Matrix_double___unary -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___scalar_matrix" c_CasADi__Matrix_double___scalar_matrix :: CInt -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') casADi__Matrix_double___scalar_matrix :: Int -> DMatrix -> DMatrix -> IO DMatrix casADi__Matrix_double___scalar_matrix x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_double___scalar_matrix x0' x1' x2' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Create >nodes by their ID. -} dmatrix_scalar_matrix :: Int -> DMatrix -> DMatrix -> IO DMatrix dmatrix_scalar_matrix = casADi__Matrix_double___scalar_matrix -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___matrix_scalar" c_CasADi__Matrix_double___matrix_scalar :: CInt -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') casADi__Matrix_double___matrix_scalar :: Int -> DMatrix -> DMatrix -> IO DMatrix casADi__Matrix_double___matrix_scalar x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_double___matrix_scalar x0' x1' x2' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Create >nodes by their ID. -} dmatrix_matrix_scalar :: Int -> DMatrix -> DMatrix -> IO DMatrix dmatrix_matrix_scalar = casADi__Matrix_double___matrix_scalar -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___matrix_matrix" c_CasADi__Matrix_double___matrix_matrix :: CInt -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') casADi__Matrix_double___matrix_matrix :: Int -> DMatrix -> DMatrix -> IO DMatrix casADi__Matrix_double___matrix_matrix x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_double___matrix_matrix x0' x1' x2' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Create >nodes by their ID. -} dmatrix_matrix_matrix :: Int -> DMatrix -> DMatrix -> IO DMatrix dmatrix_matrix_matrix = casADi__Matrix_double___matrix_matrix -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double_____add__" c_CasADi__Matrix_double_____add__ :: Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') casADi__Matrix_double_____add__ :: DMatrix -> DMatrix -> IO DMatrix casADi__Matrix_double_____add__ x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_double_____add__ x0' x1' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Elementwise >operations Octave/Python naming. -} dmatrix___add__ :: DMatrixClass a => a -> DMatrix -> IO DMatrix dmatrix___add__ x = casADi__Matrix_double_____add__ (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double_____sub__" c_CasADi__Matrix_double_____sub__ :: Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') casADi__Matrix_double_____sub__ :: DMatrix -> DMatrix -> IO DMatrix casADi__Matrix_double_____sub__ x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_double_____sub__ x0' x1' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Elementwise >operations Octave/Python naming. -} dmatrix___sub__ :: DMatrixClass a => a -> DMatrix -> IO DMatrix dmatrix___sub__ x = casADi__Matrix_double_____sub__ (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double_____mul__" c_CasADi__Matrix_double_____mul__ :: Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') casADi__Matrix_double_____mul__ :: DMatrix -> DMatrix -> IO DMatrix casADi__Matrix_double_____mul__ x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_double_____mul__ x0' x1' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Elementwise >operations Octave/Python naming. -} dmatrix___mul__ :: DMatrixClass a => a -> DMatrix -> IO DMatrix dmatrix___mul__ x = casADi__Matrix_double_____mul__ (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double_____div__" c_CasADi__Matrix_double_____div__ :: Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') casADi__Matrix_double_____div__ :: DMatrix -> DMatrix -> IO DMatrix casADi__Matrix_double_____div__ x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_double_____div__ x0' x1' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Elementwise >operations Octave/Python naming. -} dmatrix___div__ :: DMatrixClass a => a -> DMatrix -> IO DMatrix dmatrix___div__ x = casADi__Matrix_double_____div__ (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double_____lt__" c_CasADi__Matrix_double_____lt__ :: Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') casADi__Matrix_double_____lt__ :: DMatrix -> DMatrix -> IO DMatrix casADi__Matrix_double_____lt__ x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_double_____lt__ x0' x1' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Elementwise >operations Octave/Python naming. -} dmatrix___lt__ :: DMatrixClass a => a -> DMatrix -> IO DMatrix dmatrix___lt__ x = casADi__Matrix_double_____lt__ (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double_____le__" c_CasADi__Matrix_double_____le__ :: Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') casADi__Matrix_double_____le__ :: DMatrix -> DMatrix -> IO DMatrix casADi__Matrix_double_____le__ x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_double_____le__ x0' x1' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Elementwise >operations Octave/Python naming. -} dmatrix___le__ :: DMatrixClass a => a -> DMatrix -> IO DMatrix dmatrix___le__ x = casADi__Matrix_double_____le__ (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double_____eq__" c_CasADi__Matrix_double_____eq__ :: Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') casADi__Matrix_double_____eq__ :: DMatrix -> DMatrix -> IO DMatrix casADi__Matrix_double_____eq__ x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_double_____eq__ x0' x1' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Elementwise >operations Octave/Python naming. -} dmatrix___eq__ :: DMatrixClass a => a -> DMatrix -> IO DMatrix dmatrix___eq__ x = casADi__Matrix_double_____eq__ (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double_____ne__" c_CasADi__Matrix_double_____ne__ :: Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') casADi__Matrix_double_____ne__ :: DMatrix -> DMatrix -> IO DMatrix casADi__Matrix_double_____ne__ x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_double_____ne__ x0' x1' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Elementwise >operations Octave/Python naming. -} dmatrix___ne__ :: DMatrixClass a => a -> DMatrix -> IO DMatrix dmatrix___ne__ x = casADi__Matrix_double_____ne__ (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double_____truediv__" c_CasADi__Matrix_double_____truediv__ :: Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') casADi__Matrix_double_____truediv__ :: DMatrix -> DMatrix -> IO DMatrix casADi__Matrix_double_____truediv__ x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_double_____truediv__ x0' x1' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Elementwise >operations Octave/Python naming. -} dmatrix___truediv__ :: DMatrixClass a => a -> DMatrix -> IO DMatrix dmatrix___truediv__ x = casADi__Matrix_double_____truediv__ (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double_____pow__" c_CasADi__Matrix_double_____pow__ :: Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') casADi__Matrix_double_____pow__ :: DMatrix -> DMatrix -> IO DMatrix casADi__Matrix_double_____pow__ x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_double_____pow__ x0' x1' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Elementwise >operations Octave/Python naming. -} dmatrix___pow__ :: DMatrixClass a => a -> DMatrix -> IO DMatrix dmatrix___pow__ x = casADi__Matrix_double_____pow__ (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double_____constpow__" c_CasADi__Matrix_double_____constpow__ :: Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') casADi__Matrix_double_____constpow__ :: DMatrix -> DMatrix -> IO DMatrix casADi__Matrix_double_____constpow__ x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_double_____constpow__ x0' x1' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Elementwise >operations Octave/Python naming. -} dmatrix___constpow__ :: DMatrixClass a => a -> DMatrix -> IO DMatrix dmatrix___constpow__ x = casADi__Matrix_double_____constpow__ (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double_____mpower__" c_CasADi__Matrix_double_____mpower__ :: Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') casADi__Matrix_double_____mpower__ :: DMatrix -> DMatrix -> IO DMatrix casADi__Matrix_double_____mpower__ x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_double_____mpower__ x0' x1' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Elementwise >operations Octave/Python naming. -} dmatrix___mpower__ :: DMatrixClass a => a -> DMatrix -> IO DMatrix dmatrix___mpower__ x = casADi__Matrix_double_____mpower__ (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double_____mrdivide__" c_CasADi__Matrix_double_____mrdivide__ :: Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') casADi__Matrix_double_____mrdivide__ :: DMatrix -> DMatrix -> IO DMatrix casADi__Matrix_double_____mrdivide__ x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_double_____mrdivide__ x0' x1' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Elementwise >operations Octave/Python naming. -} dmatrix___mrdivide__ :: DMatrixClass a => a -> DMatrix -> IO DMatrix dmatrix___mrdivide__ x = casADi__Matrix_double_____mrdivide__ (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___mul_full" c_CasADi__Matrix_double___mul_full :: Ptr DMatrix' -> Ptr DMatrix' -> Ptr Sparsity' -> IO (Ptr DMatrix') casADi__Matrix_double___mul_full :: DMatrix -> DMatrix -> Sparsity -> IO DMatrix casADi__Matrix_double___mul_full x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_double___mul_full x0' x1' x2' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Matrix-matrix >product. -} dmatrix_mul_full :: DMatrixClass a => a -> DMatrix -> Sparsity -> IO DMatrix dmatrix_mul_full x = casADi__Matrix_double___mul_full (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___mul_full_TIC" c_CasADi__Matrix_double___mul_full_TIC :: Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') casADi__Matrix_double___mul_full' :: DMatrix -> DMatrix -> IO DMatrix casADi__Matrix_double___mul_full' x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_double___mul_full_TIC x0' x1' >>= wrapReturn -- classy wrapper dmatrix_mul_full' :: DMatrixClass a => a -> DMatrix -> IO DMatrix dmatrix_mul_full' x = casADi__Matrix_double___mul_full' (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___mul" c_CasADi__Matrix_double___mul :: Ptr DMatrix' -> Ptr DMatrix' -> Ptr Sparsity' -> IO (Ptr DMatrix') casADi__Matrix_double___mul :: DMatrix -> DMatrix -> Sparsity -> IO DMatrix casADi__Matrix_double___mul x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_double___mul x0' x1' x2' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Matrix-matrix >product. -} dmatrix_mul :: DMatrixClass a => a -> DMatrix -> Sparsity -> IO DMatrix dmatrix_mul x = casADi__Matrix_double___mul (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___mul_TIC" c_CasADi__Matrix_double___mul_TIC :: Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') casADi__Matrix_double___mul' :: DMatrix -> DMatrix -> IO DMatrix casADi__Matrix_double___mul' x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_double___mul_TIC x0' x1' >>= wrapReturn -- classy wrapper dmatrix_mul' :: DMatrixClass a => a -> DMatrix -> IO DMatrix dmatrix_mul' x = casADi__Matrix_double___mul' (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___mul_no_alloc_nn" c_CasADi__Matrix_double___mul_no_alloc_nn :: Ptr DMatrix' -> Ptr DMatrix' -> Ptr DMatrix' -> IO () casADi__Matrix_double___mul_no_alloc_nn :: DMatrix -> DMatrix -> DMatrix -> IO () casADi__Matrix_double___mul_no_alloc_nn x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_double___mul_no_alloc_nn x0' x1' x2' >>= wrapReturn -- classy wrapper dmatrix_mul_no_alloc_nn :: DMatrix -> DMatrix -> DMatrix -> IO () dmatrix_mul_no_alloc_nn = casADi__Matrix_double___mul_no_alloc_nn -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___mul_no_alloc_tn" c_CasADi__Matrix_double___mul_no_alloc_tn :: Ptr DMatrix' -> Ptr DMatrix' -> Ptr DMatrix' -> IO () casADi__Matrix_double___mul_no_alloc_tn :: DMatrix -> DMatrix -> DMatrix -> IO () casADi__Matrix_double___mul_no_alloc_tn x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_double___mul_no_alloc_tn x0' x1' x2' >>= wrapReturn -- classy wrapper dmatrix_mul_no_alloc_tn :: DMatrix -> DMatrix -> DMatrix -> IO () dmatrix_mul_no_alloc_tn = casADi__Matrix_double___mul_no_alloc_tn -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___mul_no_alloc_nt" c_CasADi__Matrix_double___mul_no_alloc_nt :: Ptr DMatrix' -> Ptr DMatrix' -> Ptr DMatrix' -> IO () casADi__Matrix_double___mul_no_alloc_nt :: DMatrix -> DMatrix -> DMatrix -> IO () casADi__Matrix_double___mul_no_alloc_nt x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_double___mul_no_alloc_nt x0' x1' x2' >>= wrapReturn -- classy wrapper dmatrix_mul_no_alloc_nt :: DMatrix -> DMatrix -> DMatrix -> IO () dmatrix_mul_no_alloc_nt = casADi__Matrix_double___mul_no_alloc_nt -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___mul_no_alloc_tn_TIC" c_CasADi__Matrix_double___mul_no_alloc_tn_TIC :: Ptr DMatrix' -> Ptr (CppVec CDouble) -> Ptr (CppVec CDouble) -> IO () casADi__Matrix_double___mul_no_alloc_tn' :: DMatrix -> Vector Double -> Vector Double -> IO () casADi__Matrix_double___mul_no_alloc_tn' x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_double___mul_no_alloc_tn_TIC x0' x1' x2' >>= wrapReturn -- classy wrapper dmatrix_mul_no_alloc_tn' :: DMatrix -> Vector Double -> Vector Double -> IO () dmatrix_mul_no_alloc_tn' = casADi__Matrix_double___mul_no_alloc_tn' -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___mul_no_alloc_nn_TIC" c_CasADi__Matrix_double___mul_no_alloc_nn_TIC :: Ptr DMatrix' -> Ptr (CppVec CDouble) -> Ptr (CppVec CDouble) -> IO () casADi__Matrix_double___mul_no_alloc_nn' :: DMatrix -> Vector Double -> Vector Double -> IO () casADi__Matrix_double___mul_no_alloc_nn' x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_double___mul_no_alloc_nn_TIC x0' x1' x2' >>= wrapReturn -- classy wrapper dmatrix_mul_no_alloc_nn' :: DMatrix -> Vector Double -> Vector Double -> IO () dmatrix_mul_no_alloc_nn' = casADi__Matrix_double___mul_no_alloc_nn' -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___quad_form" c_CasADi__Matrix_double___quad_form :: Ptr DMatrix' -> Ptr (CppVec CDouble) -> IO CDouble casADi__Matrix_double___quad_form :: DMatrix -> Vector Double -> IO Double casADi__Matrix_double___quad_form x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_double___quad_form x0' x1' >>= wrapReturn -- classy wrapper dmatrix_quad_form :: DMatrix -> Vector Double -> IO Double dmatrix_quad_form = casADi__Matrix_double___quad_form -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___trans" c_CasADi__Matrix_double___trans :: Ptr DMatrix' -> IO (Ptr DMatrix') casADi__Matrix_double___trans :: DMatrix -> IO DMatrix casADi__Matrix_double___trans x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_double___trans x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Transpose the >matrix. -} dmatrix_trans :: DMatrixClass a => a -> IO DMatrix dmatrix_trans x = casADi__Matrix_double___trans (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___sin" c_CasADi__Matrix_double___sin :: Ptr DMatrix' -> IO (Ptr DMatrix') casADi__Matrix_double___sin :: DMatrix -> IO DMatrix casADi__Matrix_double___sin x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_double___sin x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Operations defined >in the standard namespace for unambigous access and Numpy compatibility. -} dmatrix_sin :: DMatrixClass a => a -> IO DMatrix dmatrix_sin x = casADi__Matrix_double___sin (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___cos" c_CasADi__Matrix_double___cos :: Ptr DMatrix' -> IO (Ptr DMatrix') casADi__Matrix_double___cos :: DMatrix -> IO DMatrix casADi__Matrix_double___cos x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_double___cos x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Operations defined >in the standard namespace for unambigous access and Numpy compatibility. -} dmatrix_cos :: DMatrixClass a => a -> IO DMatrix dmatrix_cos x = casADi__Matrix_double___cos (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___tan" c_CasADi__Matrix_double___tan :: Ptr DMatrix' -> IO (Ptr DMatrix') casADi__Matrix_double___tan :: DMatrix -> IO DMatrix casADi__Matrix_double___tan x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_double___tan x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Operations defined >in the standard namespace for unambigous access and Numpy compatibility. -} dmatrix_tan :: DMatrixClass a => a -> IO DMatrix dmatrix_tan x = casADi__Matrix_double___tan (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___arcsin" c_CasADi__Matrix_double___arcsin :: Ptr DMatrix' -> IO (Ptr DMatrix') casADi__Matrix_double___arcsin :: DMatrix -> IO DMatrix casADi__Matrix_double___arcsin x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_double___arcsin x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Operations >defined in the standard namespace for unambigous access and Numpy >compatibility. -} dmatrix_arcsin :: DMatrixClass a => a -> IO DMatrix dmatrix_arcsin x = casADi__Matrix_double___arcsin (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___arccos" c_CasADi__Matrix_double___arccos :: Ptr DMatrix' -> IO (Ptr DMatrix') casADi__Matrix_double___arccos :: DMatrix -> IO DMatrix casADi__Matrix_double___arccos x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_double___arccos x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Operations >defined in the standard namespace for unambigous access and Numpy >compatibility. -} dmatrix_arccos :: DMatrixClass a => a -> IO DMatrix dmatrix_arccos x = casADi__Matrix_double___arccos (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___arctan" c_CasADi__Matrix_double___arctan :: Ptr DMatrix' -> IO (Ptr DMatrix') casADi__Matrix_double___arctan :: DMatrix -> IO DMatrix casADi__Matrix_double___arctan x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_double___arctan x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Operations >defined in the standard namespace for unambigous access and Numpy >compatibility. -} dmatrix_arctan :: DMatrixClass a => a -> IO DMatrix dmatrix_arctan x = casADi__Matrix_double___arctan (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___exp" c_CasADi__Matrix_double___exp :: Ptr DMatrix' -> IO (Ptr DMatrix') casADi__Matrix_double___exp :: DMatrix -> IO DMatrix casADi__Matrix_double___exp x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_double___exp x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Operations defined >in the standard namespace for unambigous access and Numpy compatibility. -} dmatrix_exp :: DMatrixClass a => a -> IO DMatrix dmatrix_exp x = casADi__Matrix_double___exp (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___log" c_CasADi__Matrix_double___log :: Ptr DMatrix' -> IO (Ptr DMatrix') casADi__Matrix_double___log :: DMatrix -> IO DMatrix casADi__Matrix_double___log x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_double___log x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Operations defined >in the standard namespace for unambigous access and Numpy compatibility. -} dmatrix_log :: DMatrixClass a => a -> IO DMatrix dmatrix_log x = casADi__Matrix_double___log (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___sqrt" c_CasADi__Matrix_double___sqrt :: Ptr DMatrix' -> IO (Ptr DMatrix') casADi__Matrix_double___sqrt :: DMatrix -> IO DMatrix casADi__Matrix_double___sqrt x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_double___sqrt x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Operations defined >in the standard namespace for unambigous access and Numpy compatibility. -} dmatrix_sqrt :: DMatrixClass a => a -> IO DMatrix dmatrix_sqrt x = casADi__Matrix_double___sqrt (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___floor" c_CasADi__Matrix_double___floor :: Ptr DMatrix' -> IO (Ptr DMatrix') casADi__Matrix_double___floor :: DMatrix -> IO DMatrix casADi__Matrix_double___floor x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_double___floor x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Operations defined >in the standard namespace for unambigous access and Numpy compatibility. -} dmatrix_floor :: DMatrixClass a => a -> IO DMatrix dmatrix_floor x = casADi__Matrix_double___floor (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___ceil" c_CasADi__Matrix_double___ceil :: Ptr DMatrix' -> IO (Ptr DMatrix') casADi__Matrix_double___ceil :: DMatrix -> IO DMatrix casADi__Matrix_double___ceil x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_double___ceil x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Operations defined >in the standard namespace for unambigous access and Numpy compatibility. -} dmatrix_ceil :: DMatrixClass a => a -> IO DMatrix dmatrix_ceil x = casADi__Matrix_double___ceil (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___fabs" c_CasADi__Matrix_double___fabs :: Ptr DMatrix' -> IO (Ptr DMatrix') casADi__Matrix_double___fabs :: DMatrix -> IO DMatrix casADi__Matrix_double___fabs x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_double___fabs x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Operations defined >in the standard namespace for unambigous access and Numpy compatibility. -} dmatrix_fabs :: DMatrixClass a => a -> IO DMatrix dmatrix_fabs x = casADi__Matrix_double___fabs (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___sign" c_CasADi__Matrix_double___sign :: Ptr DMatrix' -> IO (Ptr DMatrix') casADi__Matrix_double___sign :: DMatrix -> IO DMatrix casADi__Matrix_double___sign x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_double___sign x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Operations defined >in the standard namespace for unambigous access and Numpy compatibility. -} dmatrix_sign :: DMatrixClass a => a -> IO DMatrix dmatrix_sign x = casADi__Matrix_double___sign (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double_____copysign__" c_CasADi__Matrix_double_____copysign__ :: Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') casADi__Matrix_double_____copysign__ :: DMatrix -> DMatrix -> IO DMatrix casADi__Matrix_double_____copysign__ x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_double_____copysign__ x0' x1' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Operations >defined in the standard namespace for unambigous access and Numpy >compatibility. -} dmatrix___copysign__ :: DMatrixClass a => a -> DMatrix -> IO DMatrix dmatrix___copysign__ x = casADi__Matrix_double_____copysign__ (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___erfinv" c_CasADi__Matrix_double___erfinv :: Ptr DMatrix' -> IO (Ptr DMatrix') casADi__Matrix_double___erfinv :: DMatrix -> IO DMatrix casADi__Matrix_double___erfinv x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_double___erfinv x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Operations >defined in the standard namespace for unambigous access and Numpy >compatibility. -} dmatrix_erfinv :: DMatrixClass a => a -> IO DMatrix dmatrix_erfinv x = casADi__Matrix_double___erfinv (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___fmin" c_CasADi__Matrix_double___fmin :: Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') casADi__Matrix_double___fmin :: DMatrix -> DMatrix -> IO DMatrix casADi__Matrix_double___fmin x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_double___fmin x0' x1' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Operations defined >in the standard namespace for unambigous access and Numpy compatibility. -} dmatrix_fmin :: DMatrixClass a => a -> DMatrix -> IO DMatrix dmatrix_fmin x = casADi__Matrix_double___fmin (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___fmax" c_CasADi__Matrix_double___fmax :: Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') casADi__Matrix_double___fmax :: DMatrix -> DMatrix -> IO DMatrix casADi__Matrix_double___fmax x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_double___fmax x0' x1' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Operations defined >in the standard namespace for unambigous access and Numpy compatibility. -} dmatrix_fmax :: DMatrixClass a => a -> DMatrix -> IO DMatrix dmatrix_fmax x = casADi__Matrix_double___fmax (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___erf" c_CasADi__Matrix_double___erf :: Ptr DMatrix' -> IO (Ptr DMatrix') casADi__Matrix_double___erf :: DMatrix -> IO DMatrix casADi__Matrix_double___erf x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_double___erf x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Operations defined >in the standard namespace for unambigous access and Numpy compatibility. -} dmatrix_erf :: DMatrixClass a => a -> IO DMatrix dmatrix_erf x = casADi__Matrix_double___erf (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___sinh" c_CasADi__Matrix_double___sinh :: Ptr DMatrix' -> IO (Ptr DMatrix') casADi__Matrix_double___sinh :: DMatrix -> IO DMatrix casADi__Matrix_double___sinh x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_double___sinh x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Operations defined >in the standard namespace for unambigous access and Numpy compatibility. -} dmatrix_sinh :: DMatrixClass a => a -> IO DMatrix dmatrix_sinh x = casADi__Matrix_double___sinh (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___cosh" c_CasADi__Matrix_double___cosh :: Ptr DMatrix' -> IO (Ptr DMatrix') casADi__Matrix_double___cosh :: DMatrix -> IO DMatrix casADi__Matrix_double___cosh x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_double___cosh x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Operations defined >in the standard namespace for unambigous access and Numpy compatibility. -} dmatrix_cosh :: DMatrixClass a => a -> IO DMatrix dmatrix_cosh x = casADi__Matrix_double___cosh (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___tanh" c_CasADi__Matrix_double___tanh :: Ptr DMatrix' -> IO (Ptr DMatrix') casADi__Matrix_double___tanh :: DMatrix -> IO DMatrix casADi__Matrix_double___tanh x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_double___tanh x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Operations defined >in the standard namespace for unambigous access and Numpy compatibility. -} dmatrix_tanh :: DMatrixClass a => a -> IO DMatrix dmatrix_tanh x = casADi__Matrix_double___tanh (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___arcsinh" c_CasADi__Matrix_double___arcsinh :: Ptr DMatrix' -> IO (Ptr DMatrix') casADi__Matrix_double___arcsinh :: DMatrix -> IO DMatrix casADi__Matrix_double___arcsinh x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_double___arcsinh x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Operations >defined in the standard namespace for unambigous access and Numpy >compatibility. -} dmatrix_arcsinh :: DMatrixClass a => a -> IO DMatrix dmatrix_arcsinh x = casADi__Matrix_double___arcsinh (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___arccosh" c_CasADi__Matrix_double___arccosh :: Ptr DMatrix' -> IO (Ptr DMatrix') casADi__Matrix_double___arccosh :: DMatrix -> IO DMatrix casADi__Matrix_double___arccosh x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_double___arccosh x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Operations >defined in the standard namespace for unambigous access and Numpy >compatibility. -} dmatrix_arccosh :: DMatrixClass a => a -> IO DMatrix dmatrix_arccosh x = casADi__Matrix_double___arccosh (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___arctanh" c_CasADi__Matrix_double___arctanh :: Ptr DMatrix' -> IO (Ptr DMatrix') casADi__Matrix_double___arctanh :: DMatrix -> IO DMatrix casADi__Matrix_double___arctanh x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_double___arctanh x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Operations >defined in the standard namespace for unambigous access and Numpy >compatibility. -} dmatrix_arctanh :: DMatrixClass a => a -> IO DMatrix dmatrix_arctanh x = casADi__Matrix_double___arctanh (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___arctan2" c_CasADi__Matrix_double___arctan2 :: Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') casADi__Matrix_double___arctan2 :: DMatrix -> DMatrix -> IO DMatrix casADi__Matrix_double___arctan2 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_double___arctan2 x0' x1' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Operations >defined in the standard namespace for unambigous access and Numpy >compatibility. -} dmatrix_arctan2 :: DMatrixClass a => a -> DMatrix -> IO DMatrix dmatrix_arctan2 x = casADi__Matrix_double___arctan2 (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___log10" c_CasADi__Matrix_double___log10 :: Ptr DMatrix' -> IO (Ptr DMatrix') casADi__Matrix_double___log10 :: DMatrix -> IO DMatrix casADi__Matrix_double___log10 x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_double___log10 x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Operations defined >in the standard namespace for unambigous access and Numpy compatibility. -} dmatrix_log10 :: DMatrixClass a => a -> IO DMatrix dmatrix_log10 x = casADi__Matrix_double___log10 (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___printme" c_CasADi__Matrix_double___printme :: Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') casADi__Matrix_double___printme :: DMatrix -> DMatrix -> IO DMatrix casADi__Matrix_double___printme x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_double___printme x0' x1' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Operations >defined in the standard namespace for unambigous access and Numpy >compatibility. -} dmatrix_printme :: DMatrixClass a => a -> DMatrix -> IO DMatrix dmatrix_printme x = casADi__Matrix_double___printme (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___logic_not" c_CasADi__Matrix_double___logic_not :: Ptr DMatrix' -> IO (Ptr DMatrix') casADi__Matrix_double___logic_not :: DMatrix -> IO DMatrix casADi__Matrix_double___logic_not x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_double___logic_not x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Operations >defined in the standard namespace for unambigous access and Numpy >compatibility. -} dmatrix_logic_not :: DMatrixClass a => a -> IO DMatrix dmatrix_logic_not x = casADi__Matrix_double___logic_not (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___logic_and" c_CasADi__Matrix_double___logic_and :: Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') casADi__Matrix_double___logic_and :: DMatrix -> DMatrix -> IO DMatrix casADi__Matrix_double___logic_and x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_double___logic_and x0' x1' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Operations >defined in the standard namespace for unambigous access and Numpy >compatibility. -} dmatrix_logic_and :: DMatrixClass a => a -> DMatrix -> IO DMatrix dmatrix_logic_and x = casADi__Matrix_double___logic_and (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___logic_or" c_CasADi__Matrix_double___logic_or :: Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') casADi__Matrix_double___logic_or :: DMatrix -> DMatrix -> IO DMatrix casADi__Matrix_double___logic_or x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_double___logic_or x0' x1' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Operations >defined in the standard namespace for unambigous access and Numpy >compatibility. -} dmatrix_logic_or :: DMatrixClass a => a -> DMatrix -> IO DMatrix dmatrix_logic_or x = casADi__Matrix_double___logic_or (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___if_else_zero" c_CasADi__Matrix_double___if_else_zero :: Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') casADi__Matrix_double___if_else_zero :: DMatrix -> DMatrix -> IO DMatrix casADi__Matrix_double___if_else_zero x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_double___if_else_zero x0' x1' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Operations >defined in the standard namespace for unambigous access and Numpy >compatibility. -} dmatrix_if_else_zero :: DMatrixClass a => a -> DMatrix -> IO DMatrix dmatrix_if_else_zero x = casADi__Matrix_double___if_else_zero (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___setMaxNumCallsInPrint" c_CasADi__Matrix_double___setMaxNumCallsInPrint :: CLong -> IO () casADi__Matrix_double___setMaxNumCallsInPrint :: Int -> IO () casADi__Matrix_double___setMaxNumCallsInPrint x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_double___setMaxNumCallsInPrint x0' >>= wrapReturn -- classy wrapper dmatrix_setMaxNumCallsInPrint :: Int -> IO () dmatrix_setMaxNumCallsInPrint = casADi__Matrix_double___setMaxNumCallsInPrint -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___setMaxNumCallsInPrint_TIC" c_CasADi__Matrix_double___setMaxNumCallsInPrint_TIC :: IO () casADi__Matrix_double___setMaxNumCallsInPrint' :: IO () casADi__Matrix_double___setMaxNumCallsInPrint' = c_CasADi__Matrix_double___setMaxNumCallsInPrint_TIC >>= wrapReturn -- classy wrapper dmatrix_setMaxNumCallsInPrint' :: IO () dmatrix_setMaxNumCallsInPrint' = casADi__Matrix_double___setMaxNumCallsInPrint' -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___getMaxNumCallsInPrint" c_CasADi__Matrix_double___getMaxNumCallsInPrint :: IO CLong casADi__Matrix_double___getMaxNumCallsInPrint :: IO Int casADi__Matrix_double___getMaxNumCallsInPrint = c_CasADi__Matrix_double___getMaxNumCallsInPrint >>= wrapReturn -- classy wrapper dmatrix_getMaxNumCallsInPrint :: IO Int dmatrix_getMaxNumCallsInPrint = casADi__Matrix_double___getMaxNumCallsInPrint -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___setEqualityCheckingDepth" c_CasADi__Matrix_double___setEqualityCheckingDepth :: CInt -> IO () casADi__Matrix_double___setEqualityCheckingDepth :: Int -> IO () casADi__Matrix_double___setEqualityCheckingDepth x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_double___setEqualityCheckingDepth x0' >>= wrapReturn -- classy wrapper dmatrix_setEqualityCheckingDepth :: Int -> IO () dmatrix_setEqualityCheckingDepth = casADi__Matrix_double___setEqualityCheckingDepth -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___setEqualityCheckingDepth_TIC" c_CasADi__Matrix_double___setEqualityCheckingDepth_TIC :: IO () casADi__Matrix_double___setEqualityCheckingDepth' :: IO () casADi__Matrix_double___setEqualityCheckingDepth' = c_CasADi__Matrix_double___setEqualityCheckingDepth_TIC >>= wrapReturn -- classy wrapper dmatrix_setEqualityCheckingDepth' :: IO () dmatrix_setEqualityCheckingDepth' = casADi__Matrix_double___setEqualityCheckingDepth' -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___getEqualityCheckingDepth" c_CasADi__Matrix_double___getEqualityCheckingDepth :: IO CInt casADi__Matrix_double___getEqualityCheckingDepth :: IO Int casADi__Matrix_double___getEqualityCheckingDepth = c_CasADi__Matrix_double___getEqualityCheckingDepth >>= wrapReturn -- classy wrapper dmatrix_getEqualityCheckingDepth :: IO Int dmatrix_getEqualityCheckingDepth = casADi__Matrix_double___getEqualityCheckingDepth -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___className" c_CasADi__Matrix_double___className :: IO (Ptr StdString') casADi__Matrix_double___className :: IO String casADi__Matrix_double___className = c_CasADi__Matrix_double___className >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Printing. -} dmatrix_className :: IO String dmatrix_className = casADi__Matrix_double___className -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___printScalar_TIC" c_CasADi__Matrix_double___printScalar_TIC :: Ptr DMatrix' -> IO () casADi__Matrix_double___printScalar' :: DMatrix -> IO () casADi__Matrix_double___printScalar' x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_double___printScalar_TIC x0' >>= wrapReturn -- classy wrapper dmatrix_printScalar' :: DMatrixClass a => a -> IO () dmatrix_printScalar' x = casADi__Matrix_double___printScalar' (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___printVector_TIC" c_CasADi__Matrix_double___printVector_TIC :: Ptr DMatrix' -> IO () casADi__Matrix_double___printVector' :: DMatrix -> IO () casADi__Matrix_double___printVector' x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_double___printVector_TIC x0' >>= wrapReturn -- classy wrapper dmatrix_printVector' :: DMatrixClass a => a -> IO () dmatrix_printVector' x = casADi__Matrix_double___printVector' (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___printDense_TIC" c_CasADi__Matrix_double___printDense_TIC :: Ptr DMatrix' -> IO () casADi__Matrix_double___printDense' :: DMatrix -> IO () casADi__Matrix_double___printDense' x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_double___printDense_TIC x0' >>= wrapReturn -- classy wrapper dmatrix_printDense' :: DMatrixClass a => a -> IO () dmatrix_printDense' x = casADi__Matrix_double___printDense' (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___printSparse_TIC" c_CasADi__Matrix_double___printSparse_TIC :: Ptr DMatrix' -> IO () casADi__Matrix_double___printSparse' :: DMatrix -> IO () casADi__Matrix_double___printSparse' x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_double___printSparse_TIC x0' >>= wrapReturn -- classy wrapper dmatrix_printSparse' :: DMatrixClass a => a -> IO () dmatrix_printSparse' x = casADi__Matrix_double___printSparse' (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___row" c_CasADi__Matrix_double___row :: Ptr DMatrix' -> CInt -> IO CInt casADi__Matrix_double___row :: DMatrix -> Int -> IO Int casADi__Matrix_double___row x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_double___row x0' x1' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] -} dmatrix_row :: DMatrixClass a => a -> Int -> IO Int dmatrix_row x = casADi__Matrix_double___row (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___colind" c_CasADi__Matrix_double___colind :: Ptr DMatrix' -> CInt -> IO CInt casADi__Matrix_double___colind :: DMatrix -> Int -> IO Int casADi__Matrix_double___colind x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_double___colind x0' x1' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] -} dmatrix_colind :: DMatrixClass a => a -> Int -> IO Int dmatrix_colind x = casADi__Matrix_double___colind (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___clear" c_CasADi__Matrix_double___clear :: Ptr DMatrix' -> IO () casADi__Matrix_double___clear :: DMatrix -> IO () casADi__Matrix_double___clear x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_double___clear x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] -} dmatrix_clear :: DMatrixClass a => a -> IO () dmatrix_clear x = casADi__Matrix_double___clear (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___resize" c_CasADi__Matrix_double___resize :: Ptr DMatrix' -> CInt -> CInt -> IO () casADi__Matrix_double___resize :: DMatrix -> Int -> Int -> IO () casADi__Matrix_double___resize x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_double___resize x0' x1' x2' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] -} dmatrix_resize :: DMatrixClass a => a -> Int -> Int -> IO () dmatrix_resize x = casADi__Matrix_double___resize (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___reserve" c_CasADi__Matrix_double___reserve :: Ptr DMatrix' -> CInt -> IO () casADi__Matrix_double___reserve :: DMatrix -> Int -> IO () casADi__Matrix_double___reserve x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_double___reserve x0' x1' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] -} dmatrix_reserve :: DMatrixClass a => a -> Int -> IO () dmatrix_reserve x = casADi__Matrix_double___reserve (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___reserve_TIC" c_CasADi__Matrix_double___reserve_TIC :: Ptr DMatrix' -> CInt -> CInt -> IO () casADi__Matrix_double___reserve' :: DMatrix -> Int -> Int -> IO () casADi__Matrix_double___reserve' x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_double___reserve_TIC x0' x1' x2' >>= wrapReturn -- classy wrapper dmatrix_reserve' :: DMatrixClass a => a -> Int -> Int -> IO () dmatrix_reserve' x = casADi__Matrix_double___reserve' (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___erase" c_CasADi__Matrix_double___erase :: Ptr DMatrix' -> Ptr (CppVec CInt) -> Ptr (CppVec CInt) -> IO () casADi__Matrix_double___erase :: DMatrix -> Vector Int -> Vector Int -> IO () casADi__Matrix_double___erase x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_double___erase x0' x1' x2' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Erase a submatrix >Erase rows and/or columns of a matrix. -} dmatrix_erase :: DMatrixClass a => a -> Vector Int -> Vector Int -> IO () dmatrix_erase x = casADi__Matrix_double___erase (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___remove" c_CasADi__Matrix_double___remove :: Ptr DMatrix' -> Ptr (CppVec CInt) -> Ptr (CppVec CInt) -> IO () casADi__Matrix_double___remove :: DMatrix -> Vector Int -> Vector Int -> IO () casADi__Matrix_double___remove x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_double___remove x0' x1' x2' >>= wrapReturn -- classy wrapper {-| > [INTERNAL] Remove cols or >rows Rremove/delete rows and/or columns of a matrix. -} dmatrix_remove :: DMatrixClass a => a -> Vector Int -> Vector Int -> IO () dmatrix_remove x = casADi__Matrix_double___remove (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___enlarge" c_CasADi__Matrix_double___enlarge :: Ptr DMatrix' -> CInt -> CInt -> Ptr (CppVec CInt) -> Ptr (CppVec CInt) -> IO () casADi__Matrix_double___enlarge :: DMatrix -> Int -> Int -> Vector Int -> Vector Int -> IO () casADi__Matrix_double___enlarge x0 x1 x2 x3 x4 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> withMarshal x4 $ \x4' -> c_CasADi__Matrix_double___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. -} dmatrix_enlarge :: DMatrixClass a => a -> Int -> Int -> Vector Int -> Vector Int -> IO () dmatrix_enlarge x = casADi__Matrix_double___enlarge (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___data" c_CasADi__Matrix_double___data :: Ptr DMatrix' -> IO (Ptr (CppVec CDouble)) casADi__Matrix_double___data :: DMatrix -> IO (Vector Double) casADi__Matrix_double___data x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_double___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. -} dmatrix_data :: DMatrixClass a => a -> IO (Vector Double) dmatrix_data x = casADi__Matrix_double___data (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___sparsityRef" c_CasADi__Matrix_double___sparsityRef :: Ptr DMatrix' -> IO (Ptr Sparsity') casADi__Matrix_double___sparsityRef :: DMatrix -> IO Sparsity casADi__Matrix_double___sparsityRef x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_double___sparsityRef x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Access the >sparsity, make a copy if there are multiple references to it. -} dmatrix_sparsityRef :: DMatrixClass a => a -> IO Sparsity dmatrix_sparsityRef x = casADi__Matrix_double___sparsityRef (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___set" c_CasADi__Matrix_double___set :: Ptr DMatrix' -> CDouble -> CInt -> IO () casADi__Matrix_double___set :: DMatrix -> Double -> SparsityType -> IO () casADi__Matrix_double___set x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_double___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. -} dmatrix_set :: DMatrixClass a => a -> Double -> SparsityType -> IO () dmatrix_set x = casADi__Matrix_double___set (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___set_TIC" c_CasADi__Matrix_double___set_TIC :: Ptr DMatrix' -> CDouble -> IO () casADi__Matrix_double___set' :: DMatrix -> Double -> IO () casADi__Matrix_double___set' x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_double___set_TIC x0' x1' >>= wrapReturn -- classy wrapper dmatrix_set' :: DMatrixClass a => a -> Double -> IO () dmatrix_set' x = casADi__Matrix_double___set' (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___get" c_CasADi__Matrix_double___get :: Ptr DMatrix' -> CDouble -> CInt -> IO () casADi__Matrix_double___get :: DMatrix -> Double -> SparsityType -> IO () casADi__Matrix_double___get x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_double___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. -} dmatrix_get :: DMatrixClass a => a -> Double -> SparsityType -> IO () dmatrix_get x = casADi__Matrix_double___get (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___get_TIC" c_CasADi__Matrix_double___get_TIC :: Ptr DMatrix' -> CDouble -> IO () casADi__Matrix_double___get' :: DMatrix -> Double -> IO () casADi__Matrix_double___get' x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_double___get_TIC x0' x1' >>= wrapReturn -- classy wrapper dmatrix_get' :: DMatrixClass a => a -> Double -> IO () dmatrix_get' x = casADi__Matrix_double___get' (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___set_TIC_TIC" c_CasADi__Matrix_double___set_TIC_TIC :: Ptr DMatrix' -> Ptr (CppVec CDouble) -> CInt -> IO () casADi__Matrix_double___set'' :: DMatrix -> Vector Double -> SparsityType -> IO () casADi__Matrix_double___set'' x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_double___set_TIC_TIC x0' x1' x2' >>= wrapReturn -- classy wrapper dmatrix_set'' :: DMatrixClass a => a -> Vector Double -> SparsityType -> IO () dmatrix_set'' x = casADi__Matrix_double___set'' (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___set_TIC_TIC_TIC" c_CasADi__Matrix_double___set_TIC_TIC_TIC :: Ptr DMatrix' -> Ptr (CppVec CDouble) -> IO () casADi__Matrix_double___set''' :: DMatrix -> Vector Double -> IO () casADi__Matrix_double___set''' x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_double___set_TIC_TIC_TIC x0' x1' >>= wrapReturn -- classy wrapper dmatrix_set''' :: DMatrixClass a => a -> Vector Double -> IO () dmatrix_set''' x = casADi__Matrix_double___set''' (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___get_TIC_TIC" c_CasADi__Matrix_double___get_TIC_TIC :: Ptr DMatrix' -> Ptr (CppVec CDouble) -> CInt -> IO () casADi__Matrix_double___get'' :: DMatrix -> Vector Double -> SparsityType -> IO () casADi__Matrix_double___get'' x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_double___get_TIC_TIC x0' x1' x2' >>= wrapReturn -- classy wrapper dmatrix_get'' :: DMatrixClass a => a -> Vector Double -> SparsityType -> IO () dmatrix_get'' x = casADi__Matrix_double___get'' (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___get_TIC_TIC_TIC" c_CasADi__Matrix_double___get_TIC_TIC_TIC :: Ptr DMatrix' -> Ptr (CppVec CDouble) -> IO () casADi__Matrix_double___get''' :: DMatrix -> Vector Double -> IO () casADi__Matrix_double___get''' x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_double___get_TIC_TIC_TIC x0' x1' >>= wrapReturn -- classy wrapper dmatrix_get''' :: DMatrixClass a => a -> Vector Double -> IO () dmatrix_get''' x = casADi__Matrix_double___get''' (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___set_TIC_TIC_TIC_TIC" c_CasADi__Matrix_double___set_TIC_TIC_TIC_TIC :: Ptr DMatrix' -> Ptr DMatrix' -> CInt -> IO () casADi__Matrix_double___set'''' :: DMatrix -> DMatrix -> SparsityType -> IO () casADi__Matrix_double___set'''' x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_double___set_TIC_TIC_TIC_TIC x0' x1' x2' >>= wrapReturn -- classy wrapper dmatrix_set'''' :: DMatrixClass a => a -> DMatrix -> SparsityType -> IO () dmatrix_set'''' x = casADi__Matrix_double___set'''' (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___set_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_double___set_TIC_TIC_TIC_TIC_TIC :: Ptr DMatrix' -> Ptr DMatrix' -> IO () casADi__Matrix_double___set''''' :: DMatrix -> DMatrix -> IO () casADi__Matrix_double___set''''' x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_double___set_TIC_TIC_TIC_TIC_TIC x0' x1' >>= wrapReturn -- classy wrapper dmatrix_set''''' :: DMatrixClass a => a -> DMatrix -> IO () dmatrix_set''''' x = casADi__Matrix_double___set''''' (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___get_TIC_TIC_TIC_TIC" c_CasADi__Matrix_double___get_TIC_TIC_TIC_TIC :: Ptr DMatrix' -> Ptr DMatrix' -> CInt -> IO () casADi__Matrix_double___get'''' :: DMatrix -> DMatrix -> SparsityType -> IO () casADi__Matrix_double___get'''' x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_double___get_TIC_TIC_TIC_TIC x0' x1' x2' >>= wrapReturn -- classy wrapper dmatrix_get'''' :: DMatrixClass a => a -> DMatrix -> SparsityType -> IO () dmatrix_get'''' x = casADi__Matrix_double___get'''' (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___get_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_double___get_TIC_TIC_TIC_TIC_TIC :: Ptr DMatrix' -> Ptr DMatrix' -> IO () casADi__Matrix_double___get''''' :: DMatrix -> DMatrix -> IO () casADi__Matrix_double___get''''' x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_double___get_TIC_TIC_TIC_TIC_TIC x0' x1' >>= wrapReturn -- classy wrapper dmatrix_get''''' :: DMatrixClass a => a -> DMatrix -> IO () dmatrix_get''''' x = casADi__Matrix_double___get''''' (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___triplet" c_CasADi__Matrix_double___triplet :: Ptr (CppVec CInt) -> Ptr (CppVec CInt) -> Ptr (CppVec CDouble) -> IO (Ptr DMatrix') casADi__Matrix_double___triplet :: Vector Int -> Vector Int -> Vector Double -> IO DMatrix casADi__Matrix_double___triplet x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_double___triplet x0' x1' x2' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] -} dmatrix_triplet :: Vector Int -> Vector Int -> Vector Double -> IO DMatrix dmatrix_triplet = casADi__Matrix_double___triplet -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___triplet_TIC" c_CasADi__Matrix_double___triplet_TIC :: Ptr (CppVec CInt) -> Ptr (CppVec CInt) -> Ptr (CppVec CDouble) -> CInt -> CInt -> IO (Ptr DMatrix') casADi__Matrix_double___triplet' :: Vector Int -> Vector Int -> Vector Double -> Int -> Int -> IO DMatrix casADi__Matrix_double___triplet' x0 x1 x2 x3 x4 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> withMarshal x4 $ \x4' -> c_CasADi__Matrix_double___triplet_TIC x0' x1' x2' x3' x4' >>= wrapReturn -- classy wrapper dmatrix_triplet' :: Vector Int -> Vector Int -> Vector Double -> Int -> Int -> IO DMatrix dmatrix_triplet' = casADi__Matrix_double___triplet' -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___inf" c_CasADi__Matrix_double___inf :: Ptr Sparsity' -> IO (Ptr DMatrix') casADi__Matrix_double___inf :: Sparsity -> IO DMatrix casADi__Matrix_double___inf x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_double___inf x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] create a matrix with >all inf -} dmatrix_inf :: Sparsity -> IO DMatrix dmatrix_inf = casADi__Matrix_double___inf -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___inf_TIC" c_CasADi__Matrix_double___inf_TIC :: CInt -> CInt -> IO (Ptr DMatrix') casADi__Matrix_double___inf' :: Int -> Int -> IO DMatrix casADi__Matrix_double___inf' x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_double___inf_TIC x0' x1' >>= wrapReturn -- classy wrapper dmatrix_inf' :: Int -> Int -> IO DMatrix dmatrix_inf' = casADi__Matrix_double___inf' -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___inf_TIC_TIC" c_CasADi__Matrix_double___inf_TIC_TIC :: CInt -> IO (Ptr DMatrix') casADi__Matrix_double___inf'' :: Int -> IO DMatrix casADi__Matrix_double___inf'' x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_double___inf_TIC_TIC x0' >>= wrapReturn -- classy wrapper dmatrix_inf'' :: Int -> IO DMatrix dmatrix_inf'' = casADi__Matrix_double___inf'' -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___inf_TIC_TIC_TIC" c_CasADi__Matrix_double___inf_TIC_TIC_TIC :: IO (Ptr DMatrix') casADi__Matrix_double___inf''' :: IO DMatrix casADi__Matrix_double___inf''' = c_CasADi__Matrix_double___inf_TIC_TIC_TIC >>= wrapReturn -- classy wrapper dmatrix_inf''' :: IO DMatrix dmatrix_inf''' = casADi__Matrix_double___inf''' -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___nan" c_CasADi__Matrix_double___nan :: Ptr Sparsity' -> IO (Ptr DMatrix') casADi__Matrix_double___nan :: Sparsity -> IO DMatrix casADi__Matrix_double___nan x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_double___nan x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] create a matrix with >all nan -} dmatrix_nan :: Sparsity -> IO DMatrix dmatrix_nan = casADi__Matrix_double___nan -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___nan_TIC" c_CasADi__Matrix_double___nan_TIC :: CInt -> CInt -> IO (Ptr DMatrix') casADi__Matrix_double___nan' :: Int -> Int -> IO DMatrix casADi__Matrix_double___nan' x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_double___nan_TIC x0' x1' >>= wrapReturn -- classy wrapper dmatrix_nan' :: Int -> Int -> IO DMatrix dmatrix_nan' = casADi__Matrix_double___nan' -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___nan_TIC_TIC" c_CasADi__Matrix_double___nan_TIC_TIC :: CInt -> IO (Ptr DMatrix') casADi__Matrix_double___nan'' :: Int -> IO DMatrix casADi__Matrix_double___nan'' x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_double___nan_TIC_TIC x0' >>= wrapReturn -- classy wrapper dmatrix_nan'' :: Int -> IO DMatrix dmatrix_nan'' = casADi__Matrix_double___nan'' -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___nan_TIC_TIC_TIC" c_CasADi__Matrix_double___nan_TIC_TIC_TIC :: IO (Ptr DMatrix') casADi__Matrix_double___nan''' :: IO DMatrix casADi__Matrix_double___nan''' = c_CasADi__Matrix_double___nan_TIC_TIC_TIC >>= wrapReturn -- classy wrapper dmatrix_nan''' :: IO DMatrix dmatrix_nan''' = casADi__Matrix_double___nan''' -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___repmat" c_CasADi__Matrix_double___repmat :: CDouble -> Ptr Sparsity' -> IO (Ptr DMatrix') casADi__Matrix_double___repmat :: Double -> Sparsity -> IO DMatrix casADi__Matrix_double___repmat x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_double___repmat x0' x1' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] create a matrix >by repeating an existing matrix -} dmatrix_repmat :: Double -> Sparsity -> IO DMatrix dmatrix_repmat = casADi__Matrix_double___repmat -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___repmat_TIC" c_CasADi__Matrix_double___repmat_TIC :: Ptr DMatrix' -> Ptr Sparsity' -> IO (Ptr DMatrix') casADi__Matrix_double___repmat' :: DMatrix -> Sparsity -> IO DMatrix casADi__Matrix_double___repmat' x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_double___repmat_TIC x0' x1' >>= wrapReturn -- classy wrapper dmatrix_repmat' :: DMatrix -> Sparsity -> IO DMatrix dmatrix_repmat' = casADi__Matrix_double___repmat' -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___repmat_TIC_TIC" c_CasADi__Matrix_double___repmat_TIC_TIC :: Ptr DMatrix' -> CInt -> CInt -> IO (Ptr DMatrix') casADi__Matrix_double___repmat'' :: DMatrix -> Int -> Int -> IO DMatrix casADi__Matrix_double___repmat'' x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_double___repmat_TIC_TIC x0' x1' x2' >>= wrapReturn -- classy wrapper dmatrix_repmat'' :: DMatrix -> Int -> Int -> IO DMatrix dmatrix_repmat'' = casADi__Matrix_double___repmat'' -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___repmat_TIC_TIC_TIC" c_CasADi__Matrix_double___repmat_TIC_TIC_TIC :: Ptr DMatrix' -> CInt -> IO (Ptr DMatrix') casADi__Matrix_double___repmat''' :: DMatrix -> Int -> IO DMatrix casADi__Matrix_double___repmat''' x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_double___repmat_TIC_TIC_TIC x0' x1' >>= wrapReturn -- classy wrapper dmatrix_repmat''' :: DMatrix -> Int -> IO DMatrix dmatrix_repmat''' = casADi__Matrix_double___repmat''' -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___eye" c_CasADi__Matrix_double___eye :: CInt -> IO (Ptr DMatrix') casADi__Matrix_double___eye :: Int -> IO DMatrix casADi__Matrix_double___eye x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_double___eye x0' >>= wrapReturn -- classy wrapper dmatrix_eye :: Int -> IO DMatrix dmatrix_eye = casADi__Matrix_double___eye -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___isRegular" c_CasADi__Matrix_double___isRegular :: Ptr DMatrix' -> IO CInt casADi__Matrix_double___isRegular :: DMatrix -> IO Bool casADi__Matrix_double___isRegular x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_double___isRegular x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Checks if >expression does not contain NaN or Inf. -} dmatrix_isRegular :: DMatrixClass a => a -> IO Bool dmatrix_isRegular x = casADi__Matrix_double___isRegular (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___isSmooth" c_CasADi__Matrix_double___isSmooth :: Ptr DMatrix' -> IO CInt casADi__Matrix_double___isSmooth :: DMatrix -> IO Bool casADi__Matrix_double___isSmooth x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_double___isSmooth x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Check if >smooth. -} dmatrix_isSmooth :: DMatrixClass a => a -> IO Bool dmatrix_isSmooth x = casADi__Matrix_double___isSmooth (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___isSymbolic" c_CasADi__Matrix_double___isSymbolic :: Ptr DMatrix' -> IO CInt casADi__Matrix_double___isSymbolic :: DMatrix -> IO Bool casADi__Matrix_double___isSymbolic x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_double___isSymbolic x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Check if >symbolic (Dense) Sparse matrices invariable return false. -} dmatrix_isSymbolic :: DMatrixClass a => a -> IO Bool dmatrix_isSymbolic x = casADi__Matrix_double___isSymbolic (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___isSymbolicSparse" c_CasADi__Matrix_double___isSymbolicSparse :: Ptr DMatrix' -> IO CInt casADi__Matrix_double___isSymbolicSparse :: DMatrix -> IO Bool casADi__Matrix_double___isSymbolicSparse x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_double___isSymbolicSparse x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Check >if symbolic Sparse matrices can return true if all non-zero elements are >symbolic. -} dmatrix_isSymbolicSparse :: DMatrixClass a => a -> IO Bool dmatrix_isSymbolicSparse x = casADi__Matrix_double___isSymbolicSparse (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___isConstant" c_CasADi__Matrix_double___isConstant :: Ptr DMatrix' -> IO CInt casADi__Matrix_double___isConstant :: DMatrix -> IO Bool casADi__Matrix_double___isConstant x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_double___isConstant x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Check if the >matrix is constant (note that false negative answers are possible) -} dmatrix_isConstant :: DMatrixClass a => a -> IO Bool dmatrix_isConstant x = casADi__Matrix_double___isConstant (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___isInteger" c_CasADi__Matrix_double___isInteger :: Ptr DMatrix' -> IO CInt casADi__Matrix_double___isInteger :: DMatrix -> IO Bool casADi__Matrix_double___isInteger x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_double___isInteger x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Check if the >matrix is integer-valued (note that false negative answers are possible) -} dmatrix_isInteger :: DMatrixClass a => a -> IO Bool dmatrix_isInteger x = casADi__Matrix_double___isInteger (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___isZero" c_CasADi__Matrix_double___isZero :: Ptr DMatrix' -> IO CInt casADi__Matrix_double___isZero :: DMatrix -> IO Bool casADi__Matrix_double___isZero x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_double___isZero x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] check if the >matrix is 0 (note that false negative answers are possible) -} dmatrix_isZero :: DMatrixClass a => a -> IO Bool dmatrix_isZero x = casADi__Matrix_double___isZero (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___isOne" c_CasADi__Matrix_double___isOne :: Ptr DMatrix' -> IO CInt casADi__Matrix_double___isOne :: DMatrix -> IO Bool casADi__Matrix_double___isOne x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_double___isOne x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] check if the >matrix is 1 (note that false negative answers are possible) -} dmatrix_isOne :: DMatrixClass a => a -> IO Bool dmatrix_isOne x = casADi__Matrix_double___isOne (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___isMinusOne" c_CasADi__Matrix_double___isMinusOne :: Ptr DMatrix' -> IO CInt casADi__Matrix_double___isMinusOne :: DMatrix -> IO Bool casADi__Matrix_double___isMinusOne x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_double___isMinusOne x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] check if the >matrix is -1 (note that false negative answers are possible) -} dmatrix_isMinusOne :: DMatrixClass a => a -> IO Bool dmatrix_isMinusOne x = casADi__Matrix_double___isMinusOne (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___isIdentity" c_CasADi__Matrix_double___isIdentity :: Ptr DMatrix' -> IO CInt casADi__Matrix_double___isIdentity :: DMatrix -> IO Bool casADi__Matrix_double___isIdentity x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_double___isIdentity x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] check if the >matrix is an identity matrix (note that false negative answers are possible) -} dmatrix_isIdentity :: DMatrixClass a => a -> IO Bool dmatrix_isIdentity x = casADi__Matrix_double___isIdentity (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___isEqual" c_CasADi__Matrix_double___isEqual :: Ptr DMatrix' -> Ptr DMatrix' -> IO CInt casADi__Matrix_double___isEqual :: DMatrix -> DMatrix -> IO Bool casADi__Matrix_double___isEqual x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_double___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 -} dmatrix_isEqual :: DMatrixClass a => a -> DMatrix -> IO Bool dmatrix_isEqual x = casADi__Matrix_double___isEqual (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___hasNonStructuralZeros" c_CasADi__Matrix_double___hasNonStructuralZeros :: Ptr DMatrix' -> IO CInt casADi__Matrix_double___hasNonStructuralZeros :: DMatrix -> IO Bool casADi__Matrix_double___hasNonStructuralZeros x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_double___hasNonStructuralZeros x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] >Check if the matrix has any zero entries which are not structural zeros. -} dmatrix_hasNonStructuralZeros :: DMatrixClass a => a -> IO Bool dmatrix_hasNonStructuralZeros x = casADi__Matrix_double___hasNonStructuralZeros (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___getValue" c_CasADi__Matrix_double___getValue :: Ptr DMatrix' -> IO CDouble casADi__Matrix_double___getValue :: DMatrix -> IO Double casADi__Matrix_double___getValue x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_double___getValue x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Get double >value (only if constant) -} dmatrix_getValue :: DMatrixClass a => a -> IO Double dmatrix_getValue x = casADi__Matrix_double___getValue (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___getName" c_CasADi__Matrix_double___getName :: Ptr DMatrix' -> IO (Ptr StdString') casADi__Matrix_double___getName :: DMatrix -> IO String casADi__Matrix_double___getName x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_double___getName x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Get name (only >if symbolic scalar) -} dmatrix_getName :: DMatrixClass a => a -> IO String dmatrix_getName x = casADi__Matrix_double___getName (castDMatrix x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___setPrecision" c_CasADi__Matrix_double___setPrecision :: CInt -> IO () casADi__Matrix_double___setPrecision :: Int -> IO () casADi__Matrix_double___setPrecision x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_double___setPrecision x0' >>= wrapReturn -- classy wrapper {-| >Set the 'precision, width & scientific' used in printing and serializing to >streams. -} dmatrix_setPrecision :: Int -> IO () dmatrix_setPrecision = casADi__Matrix_double___setPrecision -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___setWidth" c_CasADi__Matrix_double___setWidth :: CInt -> IO () casADi__Matrix_double___setWidth :: Int -> IO () casADi__Matrix_double___setWidth x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_double___setWidth x0' >>= wrapReturn -- classy wrapper {-| >Set the 'precision, width & scientific' used in printing and serializing to >streams. -} dmatrix_setWidth :: Int -> IO () dmatrix_setWidth = casADi__Matrix_double___setWidth -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___setScientific" c_CasADi__Matrix_double___setScientific :: CInt -> IO () casADi__Matrix_double___setScientific :: Bool -> IO () casADi__Matrix_double___setScientific x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_double___setScientific x0' >>= wrapReturn -- classy wrapper {-| >Set the 'precision, width & scientific' used in printing and serializing to >streams. -} dmatrix_setScientific :: Bool -> IO () dmatrix_setScientific = casADi__Matrix_double___setScientific -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___DMatrix" c_CasADi__Matrix_double___DMatrix :: IO (Ptr DMatrix') casADi__Matrix_double___DMatrix :: IO DMatrix casADi__Matrix_double___DMatrix = c_CasADi__Matrix_double___DMatrix >>= 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. -} dmatrix :: IO DMatrix dmatrix = casADi__Matrix_double___DMatrix -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___DMatrix_TIC" c_CasADi__Matrix_double___DMatrix_TIC :: Ptr DMatrix' -> IO (Ptr DMatrix') casADi__Matrix_double___DMatrix' :: DMatrix -> IO DMatrix casADi__Matrix_double___DMatrix' x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_double___DMatrix_TIC x0' >>= wrapReturn -- classy wrapper dmatrix' :: DMatrix -> IO DMatrix dmatrix' = casADi__Matrix_double___DMatrix' -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___DMatrix_TIC_TIC" c_CasADi__Matrix_double___DMatrix_TIC_TIC :: Ptr (CppVec (Ptr (CppVec CDouble))) -> IO (Ptr DMatrix') casADi__Matrix_double___DMatrix'' :: Vector (Vector Double) -> IO DMatrix casADi__Matrix_double___DMatrix'' x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_double___DMatrix_TIC_TIC x0' >>= wrapReturn -- classy wrapper dmatrix'' :: Vector (Vector Double) -> IO DMatrix dmatrix'' = casADi__Matrix_double___DMatrix'' -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___DMatrix_TIC_TIC_TIC" c_CasADi__Matrix_double___DMatrix_TIC_TIC_TIC :: Ptr Sparsity' -> CDouble -> IO (Ptr DMatrix') casADi__Matrix_double___DMatrix''' :: Sparsity -> Double -> IO DMatrix casADi__Matrix_double___DMatrix''' x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_double___DMatrix_TIC_TIC_TIC x0' x1' >>= wrapReturn -- classy wrapper dmatrix''' :: Sparsity -> Double -> IO DMatrix dmatrix''' = casADi__Matrix_double___DMatrix''' -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC" c_CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC :: Ptr Sparsity' -> IO (Ptr DMatrix') casADi__Matrix_double___DMatrix'''' :: Sparsity -> IO DMatrix casADi__Matrix_double___DMatrix'''' x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC x0' >>= wrapReturn -- classy wrapper dmatrix'''' :: Sparsity -> IO DMatrix dmatrix'''' = casADi__Matrix_double___DMatrix'''' -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC :: Ptr Sparsity' -> Ptr (CppVec CDouble) -> IO (Ptr DMatrix') casADi__Matrix_double___DMatrix''''' :: Sparsity -> Vector Double -> IO DMatrix casADi__Matrix_double___DMatrix''''' x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC x0' x1' >>= wrapReturn -- classy wrapper dmatrix''''' :: Sparsity -> Vector Double -> IO DMatrix dmatrix''''' = casADi__Matrix_double___DMatrix''''' -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC :: CDouble -> IO (Ptr DMatrix') casADi__Matrix_double___DMatrix'''''' :: Double -> IO DMatrix casADi__Matrix_double___DMatrix'''''' x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC x0' >>= wrapReturn -- classy wrapper dmatrix'''''' :: Double -> IO DMatrix dmatrix'''''' = casADi__Matrix_double___DMatrix'''''' -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC :: Ptr (CppVec CDouble) -> IO (Ptr DMatrix') casADi__Matrix_double___DMatrix''''''' :: Vector Double -> IO DMatrix casADi__Matrix_double___DMatrix''''''' x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' >>= wrapReturn -- classy wrapper dmatrix''''''' :: Vector Double -> IO DMatrix dmatrix''''''' = casADi__Matrix_double___DMatrix''''''' -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC :: Ptr (CppVec CDouble) -> CInt -> CInt -> IO (Ptr DMatrix') casADi__Matrix_double___DMatrix'''''''' :: Vector Double -> Int -> Int -> IO DMatrix casADi__Matrix_double___DMatrix'''''''' x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' >>= wrapReturn -- classy wrapper dmatrix'''''''' :: Vector Double -> Int -> Int -> IO DMatrix dmatrix'''''''' = casADi__Matrix_double___DMatrix'''''''' -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC :: Ptr IMatrix' -> IO (Ptr DMatrix') casADi__Matrix_double___DMatrix''''''''' :: IMatrix -> IO DMatrix casADi__Matrix_double___DMatrix''''''''' x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' >>= wrapReturn -- classy wrapper dmatrix''''''''' :: IMatrix -> IO DMatrix dmatrix''''''''' = casADi__Matrix_double___DMatrix''''''''' -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC :: Ptr (CppVec CInt) -> IO (Ptr DMatrix') casADi__Matrix_double___DMatrix'''''''''' :: Vector Int -> IO DMatrix casADi__Matrix_double___DMatrix'''''''''' x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' >>= wrapReturn -- classy wrapper dmatrix'''''''''' :: Vector Int -> IO DMatrix dmatrix'''''''''' = casADi__Matrix_double___DMatrix'''''''''' -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC :: Ptr (CppVec CInt) -> CInt -> CInt -> IO (Ptr DMatrix') casADi__Matrix_double___DMatrix''''''''''' :: Vector Int -> Int -> Int -> IO DMatrix casADi__Matrix_double___DMatrix''''''''''' x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' >>= wrapReturn -- classy wrapper dmatrix''''''''''' :: Vector Int -> Int -> Int -> IO DMatrix dmatrix''''''''''' = casADi__Matrix_double___DMatrix'''''''''''