{-# OPTIONS_GHC -Wall #-} {-# OPTIONS_GHC -fno-warn-unused-imports #-} {-# OPTIONS_GHC -fno-warn-orphans #-} {-# Language ForeignFunctionInterface #-} {-# Language FlexibleInstances #-} {-# Language MultiParamTypeClasses #-} module Casadi.Wrappers.Classes.SX ( SX, SXClass(..), sx, sx', sx'', sx''', sx'''', sx''''', sx'''''', sx''''''', sx'''''''', sx''''''''', sx'''''''''', sx''''''''''', sx'''''''''''', sx''''''''''''', sx'''''''''''''', sx___add__, sx___constpow__, sx___copysign__, sx___div__, sx___eq__, sx___le__, sx___lt__, sx___mpower__, sx___mrdivide__, sx___mul__, sx___ne__, sx___nonzero__, sx___pow__, sx___sub__, sx___truediv__, sx_append, sx_appendColumns, sx_arccos, sx_arccosh, sx_arcsin, sx_arcsinh, sx_arctan, sx_arctan2, sx_arctanh, sx_at, sx_binary, sx_ceil, sx_className, sx_clear, sx_colind, sx_cos, sx_cosh, sx_data, sx_densify, sx_densify', sx_elem, sx_elem', sx_enlarge, sx_erase, sx_erf, sx_erfinv, sx_exp, sx_eye, sx_fabs, sx_floor, sx_fmax, sx_fmin, sx_get, sx_get', sx_get'', sx_get''', sx_get'''', sx_get''''', sx_getEqualityCheckingDepth, sx_getMaxNumCallsInPrint, sx_getName, sx_getValue, sx_hasNZ, sx_hasNonStructuralZeros, sx_if_else_zero, sx_indexed_assignment, sx_indexed_assignment', sx_indexed_assignment'', sx_indexed_assignment''', sx_indexed_assignment'''', sx_indexed_assignment''''', sx_indexed_assignment'''''', sx_indexed_assignment''''''', sx_indexed_assignment'''''''', sx_indexed_assignment''''''''', sx_indexed_one_based_assignment, sx_indexed_one_based_assignment', sx_indexed_one_based_assignment'', sx_indexed_zero_based_assignment, sx_indexed_zero_based_assignment', sx_indexed_zero_based_assignment'', sx_inf, sx_inf', sx_inf'', sx_inf''', sx_isConstant, sx_isEqual, sx_isIdentity, sx_isInteger, sx_isMinusOne, sx_isOne, sx_isRegular, sx_isSmooth, sx_isSymbolic, sx_isSymbolicSparse, sx_isZero, sx_log, sx_log10, sx_logic_and, sx_logic_not, sx_logic_or, sx_matrix_matrix, sx_matrix_scalar, sx_mul, sx_mul', sx_mul_full, sx_mul_full', sx_mul_no_alloc_nn, sx_mul_no_alloc_nn', sx_mul_no_alloc_nt, sx_mul_no_alloc_tn, sx_mul_no_alloc_tn', sx_nan, sx_nan', sx_nan'', sx_nan''', sx_nz_indexed_assignment, sx_nz_indexed_assignment', sx_nz_indexed_one_based_assignment, sx_nz_indexed_one_based_assignment', sx_nz_indexed_zero_based_assignment, sx_nz_indexed_zero_based_assignment', sx_operator_minus, sx_operator_plus, sx_printDense', sx_printScalar', sx_printSparse', sx_printVector', sx_printme, sx_quad_form, sx_remove, sx_repmat, sx_repmat', sx_repmat'', sx_repmat''', sx_reserve, sx_reserve', sx_resize, sx_row, sx_sanityCheck, sx_sanityCheck', sx_scalar_matrix, sx_set, sx_set', sx_set'', sx_set''', sx_set'''', sx_set''''', sx_setAll, sx_setEqualityCheckingDepth, sx_setEqualityCheckingDepth', sx_setMaxNumCallsInPrint, sx_setMaxNumCallsInPrint', sx_setNZ, sx_setNZ', sx_setNZ'', sx_setNZ''', sx_setPrecision, sx_setScientific, sx_setSparse, sx_setSparse', sx_setSub, sx_setSub', sx_setSub'', sx_setSub''', sx_setSub'''', sx_setSub''''', sx_setSub'''''', sx_setSub''''''', sx_setSub'''''''', sx_setSub''''''''', sx_setSub'''''''''', sx_setSub''''''''''', sx_setSub'''''''''''', sx_setSub''''''''''''', sx_setWidth, sx_setZero, sx_sign, sx_sin, sx_sinh, sx_sparsify, sx_sparsify', sx_sparsityRef, sx_sqrt, sx_tan, sx_tanh, sx_trans, sx_triplet, sx_triplet', sx_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 SX where show = unsafePerformIO . printableObject_getDescription -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___sanityCheck" c_CasADi__Matrix_CasADi__SXElement___sanityCheck :: Ptr SX' -> CInt -> IO () casADi__Matrix_CasADi__SXElement___sanityCheck :: SX -> Bool -> IO () casADi__Matrix_CasADi__SXElement___sanityCheck x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_CasADi__SXElement___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 -} sx_sanityCheck :: SXClass a => a -> Bool -> IO () sx_sanityCheck x = casADi__Matrix_CasADi__SXElement___sanityCheck (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___sanityCheck_TIC" c_CasADi__Matrix_CasADi__SXElement___sanityCheck_TIC :: Ptr SX' -> IO () casADi__Matrix_CasADi__SXElement___sanityCheck' :: SX -> IO () casADi__Matrix_CasADi__SXElement___sanityCheck' x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_CasADi__SXElement___sanityCheck_TIC x0' >>= wrapReturn -- classy wrapper sx_sanityCheck' :: SXClass a => a -> IO () sx_sanityCheck' x = casADi__Matrix_CasADi__SXElement___sanityCheck' (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___at" c_CasADi__Matrix_CasADi__SXElement___at :: Ptr SX' -> CInt -> IO (Ptr SXElement') casADi__Matrix_CasADi__SXElement___at :: SX -> Int -> IO SXElement casADi__Matrix_CasADi__SXElement___at x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_CasADi__SXElement___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. -} sx_at :: SXClass a => a -> Int -> IO SXElement sx_at x = casADi__Matrix_CasADi__SXElement___at (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___elem" c_CasADi__Matrix_CasADi__SXElement___elem :: Ptr SX' -> CInt -> CInt -> IO (Ptr SXElement') casADi__Matrix_CasADi__SXElement___elem :: SX -> Int -> Int -> IO SXElement casADi__Matrix_CasADi__SXElement___elem x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_CasADi__SXElement___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 -} sx_elem :: SXClass a => a -> Int -> Int -> IO SXElement sx_elem x = casADi__Matrix_CasADi__SXElement___elem (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___elem_TIC" c_CasADi__Matrix_CasADi__SXElement___elem_TIC :: Ptr SX' -> CInt -> IO (Ptr SXElement') casADi__Matrix_CasADi__SXElement___elem' :: SX -> Int -> IO SXElement casADi__Matrix_CasADi__SXElement___elem' x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_CasADi__SXElement___elem_TIC x0' x1' >>= wrapReturn -- classy wrapper sx_elem' :: SXClass a => a -> Int -> IO SXElement sx_elem' x = casADi__Matrix_CasADi__SXElement___elem' (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___hasNZ" c_CasADi__Matrix_CasADi__SXElement___hasNZ :: Ptr SX' -> CInt -> CInt -> IO CInt casADi__Matrix_CasADi__SXElement___hasNZ :: SX -> Int -> Int -> IO Bool casADi__Matrix_CasADi__SXElement___hasNZ x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_CasADi__SXElement___hasNZ x0' x1' x2' >>= wrapReturn -- classy wrapper {-| >Returns true if the matrix has a non-zero at location rr,cc. -} sx_hasNZ :: SXClass a => a -> Int -> Int -> IO Bool sx_hasNZ x = casADi__Matrix_CasADi__SXElement___hasNZ (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement_____nonzero__" c_CasADi__Matrix_CasADi__SXElement_____nonzero__ :: Ptr SX' -> IO CInt casADi__Matrix_CasADi__SXElement_____nonzero__ :: SX -> IO Bool casADi__Matrix_CasADi__SXElement_____nonzero__ x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_CasADi__SXElement_____nonzero__ x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Returns the >truth value of a Matrix. -} sx___nonzero__ :: SXClass a => a -> IO Bool sx___nonzero__ x = casADi__Matrix_CasADi__SXElement_____nonzero__ (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___setSub" c_CasADi__Matrix_CasADi__SXElement___setSub :: Ptr SX' -> Ptr SX' -> CInt -> CInt -> IO () casADi__Matrix_CasADi__SXElement___setSub :: SX -> SX -> Int -> Int -> IO () casADi__Matrix_CasADi__SXElement___setSub x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> c_CasADi__Matrix_CasADi__SXElement___setSub x0' x1' x2' x3' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Set a submatrix. -} sx_setSub :: SXClass a => a -> SX -> Int -> Int -> IO () sx_setSub x = casADi__Matrix_CasADi__SXElement___setSub (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___setSub_TIC" c_CasADi__Matrix_CasADi__SXElement___setSub_TIC :: Ptr SX' -> Ptr SX' -> Ptr (CppVec CInt) -> CInt -> IO () casADi__Matrix_CasADi__SXElement___setSub' :: SX -> SX -> Vector Int -> Int -> IO () casADi__Matrix_CasADi__SXElement___setSub' x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> c_CasADi__Matrix_CasADi__SXElement___setSub_TIC x0' x1' x2' x3' >>= wrapReturn -- classy wrapper sx_setSub' :: SXClass a => a -> SX -> Vector Int -> Int -> IO () sx_setSub' x = casADi__Matrix_CasADi__SXElement___setSub' (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC" c_CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC :: Ptr SX' -> Ptr SX' -> CInt -> Ptr (CppVec CInt) -> IO () casADi__Matrix_CasADi__SXElement___setSub'' :: SX -> SX -> Int -> Vector Int -> IO () casADi__Matrix_CasADi__SXElement___setSub'' x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> c_CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC x0' x1' x2' x3' >>= wrapReturn -- classy wrapper sx_setSub'' :: SXClass a => a -> SX -> Int -> Vector Int -> IO () sx_setSub'' x = casADi__Matrix_CasADi__SXElement___setSub'' (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC_TIC :: Ptr SX' -> Ptr SX' -> Ptr (CppVec CInt) -> Ptr (CppVec CInt) -> IO () casADi__Matrix_CasADi__SXElement___setSub''' :: SX -> SX -> Vector Int -> Vector Int -> IO () casADi__Matrix_CasADi__SXElement___setSub''' x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> c_CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn -- classy wrapper sx_setSub''' :: SXClass a => a -> SX -> Vector Int -> Vector Int -> IO () sx_setSub''' x = casADi__Matrix_CasADi__SXElement___setSub''' (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC_TIC_TIC :: Ptr SX' -> Ptr SX' -> Ptr Slice' -> Ptr (CppVec CInt) -> IO () casADi__Matrix_CasADi__SXElement___setSub'''' :: SX -> SX -> Slice -> Vector Int -> IO () casADi__Matrix_CasADi__SXElement___setSub'''' x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> c_CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn -- classy wrapper sx_setSub'''' :: SXClass a => a -> SX -> Slice -> Vector Int -> IO () sx_setSub'''' x = casADi__Matrix_CasADi__SXElement___setSub'''' (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC_TIC_TIC_TIC :: Ptr SX' -> Ptr SX' -> Ptr (CppVec CInt) -> Ptr Slice' -> IO () casADi__Matrix_CasADi__SXElement___setSub''''' :: SX -> SX -> Vector Int -> Slice -> IO () casADi__Matrix_CasADi__SXElement___setSub''''' x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> c_CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn -- classy wrapper sx_setSub''''' :: SXClass a => a -> SX -> Vector Int -> Slice -> IO () sx_setSub''''' x = casADi__Matrix_CasADi__SXElement___setSub''''' (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC_TIC_TIC_TIC_TIC :: Ptr SX' -> Ptr SX' -> Ptr Slice' -> Ptr Slice' -> IO () casADi__Matrix_CasADi__SXElement___setSub'''''' :: SX -> SX -> Slice -> Slice -> IO () casADi__Matrix_CasADi__SXElement___setSub'''''' x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> c_CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn -- classy wrapper sx_setSub'''''' :: SXClass a => a -> SX -> Slice -> Slice -> IO () sx_setSub'''''' x = casADi__Matrix_CasADi__SXElement___setSub'''''' (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC :: Ptr SX' -> Ptr SX' -> Ptr IMatrix' -> Ptr (CppVec CInt) -> IO () casADi__Matrix_CasADi__SXElement___setSub''''''' :: SX -> SX -> IMatrix -> Vector Int -> IO () casADi__Matrix_CasADi__SXElement___setSub''''''' x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> c_CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn -- classy wrapper sx_setSub''''''' :: SXClass a => a -> SX -> IMatrix -> Vector Int -> IO () sx_setSub''''''' x = casADi__Matrix_CasADi__SXElement___setSub''''''' (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC :: Ptr SX' -> Ptr SX' -> Ptr (CppVec CInt) -> Ptr IMatrix' -> IO () casADi__Matrix_CasADi__SXElement___setSub'''''''' :: SX -> SX -> Vector Int -> IMatrix -> IO () casADi__Matrix_CasADi__SXElement___setSub'''''''' x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> c_CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn -- classy wrapper sx_setSub'''''''' :: SXClass a => a -> SX -> Vector Int -> IMatrix -> IO () sx_setSub'''''''' x = casADi__Matrix_CasADi__SXElement___setSub'''''''' (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC :: Ptr SX' -> Ptr SX' -> Ptr IMatrix' -> Ptr Slice' -> IO () casADi__Matrix_CasADi__SXElement___setSub''''''''' :: SX -> SX -> IMatrix -> Slice -> IO () casADi__Matrix_CasADi__SXElement___setSub''''''''' x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> c_CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn -- classy wrapper sx_setSub''''''''' :: SXClass a => a -> SX -> IMatrix -> Slice -> IO () sx_setSub''''''''' x = casADi__Matrix_CasADi__SXElement___setSub''''''''' (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC :: Ptr SX' -> Ptr SX' -> Ptr Slice' -> Ptr IMatrix' -> IO () casADi__Matrix_CasADi__SXElement___setSub'''''''''' :: SX -> SX -> Slice -> IMatrix -> IO () casADi__Matrix_CasADi__SXElement___setSub'''''''''' x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> c_CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn -- classy wrapper sx_setSub'''''''''' :: SXClass a => a -> SX -> Slice -> IMatrix -> IO () sx_setSub'''''''''' x = casADi__Matrix_CasADi__SXElement___setSub'''''''''' (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC :: Ptr SX' -> Ptr SX' -> Ptr IMatrix' -> Ptr IMatrix' -> IO () casADi__Matrix_CasADi__SXElement___setSub''''''''''' :: SX -> SX -> IMatrix -> IMatrix -> IO () casADi__Matrix_CasADi__SXElement___setSub''''''''''' x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> c_CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn -- classy wrapper sx_setSub''''''''''' :: SXClass a => a -> SX -> IMatrix -> IMatrix -> IO () sx_setSub''''''''''' x = casADi__Matrix_CasADi__SXElement___setSub''''''''''' (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC :: Ptr SX' -> Ptr SX' -> Ptr Slice' -> CInt -> IO () casADi__Matrix_CasADi__SXElement___setSub'''''''''''' :: SX -> SX -> Slice -> Int -> IO () casADi__Matrix_CasADi__SXElement___setSub'''''''''''' x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> c_CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn -- classy wrapper sx_setSub'''''''''''' :: SXClass a => a -> SX -> Slice -> Int -> IO () sx_setSub'''''''''''' x = casADi__Matrix_CasADi__SXElement___setSub'''''''''''' (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC :: Ptr SX' -> Ptr SX' -> Ptr Sparsity' -> CInt -> IO () casADi__Matrix_CasADi__SXElement___setSub''''''''''''' :: SX -> SX -> Sparsity -> Int -> IO () casADi__Matrix_CasADi__SXElement___setSub''''''''''''' x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> c_CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn -- classy wrapper sx_setSub''''''''''''' :: SXClass a => a -> SX -> Sparsity -> Int -> IO () sx_setSub''''''''''''' x = casADi__Matrix_CasADi__SXElement___setSub''''''''''''' (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___setNZ" c_CasADi__Matrix_CasADi__SXElement___setNZ :: Ptr SX' -> CInt -> Ptr SX' -> IO () casADi__Matrix_CasADi__SXElement___setNZ :: SX -> Int -> SX -> IO () casADi__Matrix_CasADi__SXElement___setNZ x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_CasADi__SXElement___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. -} sx_setNZ :: SXClass a => a -> Int -> SX -> IO () sx_setNZ x = casADi__Matrix_CasADi__SXElement___setNZ (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___setNZ_TIC" c_CasADi__Matrix_CasADi__SXElement___setNZ_TIC :: Ptr SX' -> Ptr (CppVec CInt) -> Ptr SX' -> IO () casADi__Matrix_CasADi__SXElement___setNZ' :: SX -> Vector Int -> SX -> IO () casADi__Matrix_CasADi__SXElement___setNZ' x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_CasADi__SXElement___setNZ_TIC x0' x1' x2' >>= wrapReturn -- classy wrapper sx_setNZ' :: SXClass a => a -> Vector Int -> SX -> IO () sx_setNZ' x = casADi__Matrix_CasADi__SXElement___setNZ' (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___setNZ_TIC_TIC" c_CasADi__Matrix_CasADi__SXElement___setNZ_TIC_TIC :: Ptr SX' -> Ptr Slice' -> Ptr SX' -> IO () casADi__Matrix_CasADi__SXElement___setNZ'' :: SX -> Slice -> SX -> IO () casADi__Matrix_CasADi__SXElement___setNZ'' x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_CasADi__SXElement___setNZ_TIC_TIC x0' x1' x2' >>= wrapReturn -- classy wrapper sx_setNZ'' :: SXClass a => a -> Slice -> SX -> IO () sx_setNZ'' x = casADi__Matrix_CasADi__SXElement___setNZ'' (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___setNZ_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SXElement___setNZ_TIC_TIC_TIC :: Ptr SX' -> Ptr IMatrix' -> Ptr SX' -> IO () casADi__Matrix_CasADi__SXElement___setNZ''' :: SX -> IMatrix -> SX -> IO () casADi__Matrix_CasADi__SXElement___setNZ''' x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_CasADi__SXElement___setNZ_TIC_TIC_TIC x0' x1' x2' >>= wrapReturn -- classy wrapper sx_setNZ''' :: SXClass a => a -> IMatrix -> SX -> IO () sx_setNZ''' x = casADi__Matrix_CasADi__SXElement___setNZ''' (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___append" c_CasADi__Matrix_CasADi__SXElement___append :: Ptr SX' -> Ptr SX' -> IO () casADi__Matrix_CasADi__SXElement___append :: SX -> SX -> IO () casADi__Matrix_CasADi__SXElement___append x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_CasADi__SXElement___append x0' x1' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Append a matrix >vertically (NOTE: only efficient if vector) -} sx_append :: SXClass a => a -> SX -> IO () sx_append x = casADi__Matrix_CasADi__SXElement___append (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___appendColumns" c_CasADi__Matrix_CasADi__SXElement___appendColumns :: Ptr SX' -> Ptr SX' -> IO () casADi__Matrix_CasADi__SXElement___appendColumns :: SX -> SX -> IO () casADi__Matrix_CasADi__SXElement___appendColumns x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_CasADi__SXElement___appendColumns x0' x1' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Append a >matrix horizontally. -} sx_appendColumns :: SXClass a => a -> SX -> IO () sx_appendColumns x = casADi__Matrix_CasADi__SXElement___appendColumns (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___nz_indexed_one_based_assignment" c_CasADi__Matrix_CasADi__SXElement___nz_indexed_one_based_assignment :: Ptr SX' -> CInt -> Ptr SXElement' -> IO () casADi__Matrix_CasADi__SXElement___nz_indexed_one_based_assignment :: SX -> Int -> SXElement -> IO () casADi__Matrix_CasADi__SXElement___nz_indexed_one_based_assignment x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_CasADi__SXElement___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 -} sx_nz_indexed_one_based_assignment :: SXClass a => a -> Int -> SXElement -> IO () sx_nz_indexed_one_based_assignment x = casADi__Matrix_CasADi__SXElement___nz_indexed_one_based_assignment (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___nz_indexed_zero_based_assignment" c_CasADi__Matrix_CasADi__SXElement___nz_indexed_zero_based_assignment :: Ptr SX' -> CInt -> Ptr SXElement' -> IO () casADi__Matrix_CasADi__SXElement___nz_indexed_zero_based_assignment :: SX -> Int -> SXElement -> IO () casADi__Matrix_CasADi__SXElement___nz_indexed_zero_based_assignment x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_CasADi__SXElement___nz_indexed_zero_based_assignment x0' x1' x2' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Indexing for interfaced languages get a non-zero -} sx_nz_indexed_zero_based_assignment :: SXClass a => a -> Int -> SXElement -> IO () sx_nz_indexed_zero_based_assignment x = casADi__Matrix_CasADi__SXElement___nz_indexed_zero_based_assignment (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___nz_indexed_assignment" c_CasADi__Matrix_CasADi__SXElement___nz_indexed_assignment :: Ptr SX' -> Ptr Slice' -> Ptr SX' -> IO () casADi__Matrix_CasADi__SXElement___nz_indexed_assignment :: SX -> Slice -> SX -> IO () casADi__Matrix_CasADi__SXElement___nz_indexed_assignment x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_CasADi__SXElement___nz_indexed_assignment x0' x1' x2' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] >Indexing for interfaced languages get a non-zero -} sx_nz_indexed_assignment :: SXClass a => a -> Slice -> SX -> IO () sx_nz_indexed_assignment x = casADi__Matrix_CasADi__SXElement___nz_indexed_assignment (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___indexed_one_based_assignment" c_CasADi__Matrix_CasADi__SXElement___indexed_one_based_assignment :: Ptr SX' -> Ptr IMatrix' -> Ptr SX' -> IO () casADi__Matrix_CasADi__SXElement___indexed_one_based_assignment :: SX -> IMatrix -> SX -> IO () casADi__Matrix_CasADi__SXElement___indexed_one_based_assignment x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_CasADi__SXElement___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 -} sx_indexed_one_based_assignment :: SXClass a => a -> IMatrix -> SX -> IO () sx_indexed_one_based_assignment x = casADi__Matrix_CasADi__SXElement___indexed_one_based_assignment (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___indexed_zero_based_assignment" c_CasADi__Matrix_CasADi__SXElement___indexed_zero_based_assignment :: Ptr SX' -> Ptr IMatrix' -> Ptr SX' -> IO () casADi__Matrix_CasADi__SXElement___indexed_zero_based_assignment :: SX -> IMatrix -> SX -> IO () casADi__Matrix_CasADi__SXElement___indexed_zero_based_assignment x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_CasADi__SXElement___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] -} sx_indexed_zero_based_assignment :: SXClass a => a -> IMatrix -> SX -> IO () sx_indexed_zero_based_assignment x = casADi__Matrix_CasADi__SXElement___indexed_zero_based_assignment (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___nz_indexed_one_based_assignment_TIC" c_CasADi__Matrix_CasADi__SXElement___nz_indexed_one_based_assignment_TIC :: Ptr SX' -> Ptr IMatrix' -> Ptr SX' -> IO () casADi__Matrix_CasADi__SXElement___nz_indexed_one_based_assignment' :: SX -> IMatrix -> SX -> IO () casADi__Matrix_CasADi__SXElement___nz_indexed_one_based_assignment' x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_CasADi__SXElement___nz_indexed_one_based_assignment_TIC x0' x1' x2' >>= wrapReturn -- classy wrapper sx_nz_indexed_one_based_assignment' :: SXClass a => a -> IMatrix -> SX -> IO () sx_nz_indexed_one_based_assignment' x = casADi__Matrix_CasADi__SXElement___nz_indexed_one_based_assignment' (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___nz_indexed_zero_based_assignment_TIC" c_CasADi__Matrix_CasADi__SXElement___nz_indexed_zero_based_assignment_TIC :: Ptr SX' -> Ptr IMatrix' -> Ptr SX' -> IO () casADi__Matrix_CasADi__SXElement___nz_indexed_zero_based_assignment' :: SX -> IMatrix -> SX -> IO () casADi__Matrix_CasADi__SXElement___nz_indexed_zero_based_assignment' x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_CasADi__SXElement___nz_indexed_zero_based_assignment_TIC x0' x1' x2' >>= wrapReturn -- classy wrapper sx_nz_indexed_zero_based_assignment' :: SXClass a => a -> IMatrix -> SX -> IO () sx_nz_indexed_zero_based_assignment' x = casADi__Matrix_CasADi__SXElement___nz_indexed_zero_based_assignment' (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___nz_indexed_assignment_TIC" c_CasADi__Matrix_CasADi__SXElement___nz_indexed_assignment_TIC :: Ptr SX' -> Ptr IndexList' -> Ptr SX' -> IO () casADi__Matrix_CasADi__SXElement___nz_indexed_assignment' :: SX -> IndexList -> SX -> IO () casADi__Matrix_CasADi__SXElement___nz_indexed_assignment' x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_CasADi__SXElement___nz_indexed_assignment_TIC x0' x1' x2' >>= wrapReturn -- classy wrapper sx_nz_indexed_assignment' :: SXClass a => a -> IndexList -> SX -> IO () sx_nz_indexed_assignment' x = casADi__Matrix_CasADi__SXElement___nz_indexed_assignment' (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___indexed_one_based_assignment_TIC" c_CasADi__Matrix_CasADi__SXElement___indexed_one_based_assignment_TIC :: Ptr SX' -> CInt -> CInt -> Ptr SXElement' -> IO () casADi__Matrix_CasADi__SXElement___indexed_one_based_assignment' :: SX -> Int -> Int -> SXElement -> IO () casADi__Matrix_CasADi__SXElement___indexed_one_based_assignment' x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> c_CasADi__Matrix_CasADi__SXElement___indexed_one_based_assignment_TIC x0' x1' x2' x3' >>= wrapReturn -- classy wrapper sx_indexed_one_based_assignment' :: SXClass a => a -> Int -> Int -> SXElement -> IO () sx_indexed_one_based_assignment' x = casADi__Matrix_CasADi__SXElement___indexed_one_based_assignment' (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___indexed_zero_based_assignment_TIC" c_CasADi__Matrix_CasADi__SXElement___indexed_zero_based_assignment_TIC :: Ptr SX' -> CInt -> CInt -> Ptr SXElement' -> IO () casADi__Matrix_CasADi__SXElement___indexed_zero_based_assignment' :: SX -> Int -> Int -> SXElement -> IO () casADi__Matrix_CasADi__SXElement___indexed_zero_based_assignment' x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> c_CasADi__Matrix_CasADi__SXElement___indexed_zero_based_assignment_TIC x0' x1' x2' x3' >>= wrapReturn -- classy wrapper sx_indexed_zero_based_assignment' :: SXClass a => a -> Int -> Int -> SXElement -> IO () sx_indexed_zero_based_assignment' x = casADi__Matrix_CasADi__SXElement___indexed_zero_based_assignment' (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___indexed_assignment" c_CasADi__Matrix_CasADi__SXElement___indexed_assignment :: Ptr SX' -> Ptr Slice' -> Ptr Slice' -> Ptr SX' -> IO () casADi__Matrix_CasADi__SXElement___indexed_assignment :: SX -> Slice -> Slice -> SX -> IO () casADi__Matrix_CasADi__SXElement___indexed_assignment x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> c_CasADi__Matrix_CasADi__SXElement___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] -} sx_indexed_assignment :: SXClass a => a -> Slice -> Slice -> SX -> IO () sx_indexed_assignment x = casADi__Matrix_CasADi__SXElement___indexed_assignment (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___indexed_assignment_TIC" c_CasADi__Matrix_CasADi__SXElement___indexed_assignment_TIC :: Ptr SX' -> Ptr IndexList' -> Ptr IndexList' -> Ptr SX' -> IO () casADi__Matrix_CasADi__SXElement___indexed_assignment' :: SX -> IndexList -> IndexList -> SX -> IO () casADi__Matrix_CasADi__SXElement___indexed_assignment' x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> c_CasADi__Matrix_CasADi__SXElement___indexed_assignment_TIC x0' x1' x2' x3' >>= wrapReturn -- classy wrapper sx_indexed_assignment' :: SXClass a => a -> IndexList -> IndexList -> SX -> IO () sx_indexed_assignment' x = casADi__Matrix_CasADi__SXElement___indexed_assignment' (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___indexed_assignment_TIC_TIC" c_CasADi__Matrix_CasADi__SXElement___indexed_assignment_TIC_TIC :: Ptr SX' -> Ptr Slice' -> Ptr IMatrix' -> Ptr SX' -> IO () casADi__Matrix_CasADi__SXElement___indexed_assignment'' :: SX -> Slice -> IMatrix -> SX -> IO () casADi__Matrix_CasADi__SXElement___indexed_assignment'' x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> c_CasADi__Matrix_CasADi__SXElement___indexed_assignment_TIC_TIC x0' x1' x2' x3' >>= wrapReturn -- classy wrapper sx_indexed_assignment'' :: SXClass a => a -> Slice -> IMatrix -> SX -> IO () sx_indexed_assignment'' x = casADi__Matrix_CasADi__SXElement___indexed_assignment'' (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___indexed_assignment_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SXElement___indexed_assignment_TIC_TIC_TIC :: Ptr SX' -> Ptr IMatrix' -> Ptr Slice' -> Ptr SX' -> IO () casADi__Matrix_CasADi__SXElement___indexed_assignment''' :: SX -> IMatrix -> Slice -> SX -> IO () casADi__Matrix_CasADi__SXElement___indexed_assignment''' x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> c_CasADi__Matrix_CasADi__SXElement___indexed_assignment_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn -- classy wrapper sx_indexed_assignment''' :: SXClass a => a -> IMatrix -> Slice -> SX -> IO () sx_indexed_assignment''' x = casADi__Matrix_CasADi__SXElement___indexed_assignment''' (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___indexed_assignment_TIC_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SXElement___indexed_assignment_TIC_TIC_TIC_TIC :: Ptr SX' -> Ptr IMatrix' -> Ptr IndexList' -> Ptr SX' -> IO () casADi__Matrix_CasADi__SXElement___indexed_assignment'''' :: SX -> IMatrix -> IndexList -> SX -> IO () casADi__Matrix_CasADi__SXElement___indexed_assignment'''' x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> c_CasADi__Matrix_CasADi__SXElement___indexed_assignment_TIC_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn -- classy wrapper sx_indexed_assignment'''' :: SXClass a => a -> IMatrix -> IndexList -> SX -> IO () sx_indexed_assignment'''' x = casADi__Matrix_CasADi__SXElement___indexed_assignment'''' (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___indexed_assignment_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SXElement___indexed_assignment_TIC_TIC_TIC_TIC_TIC :: Ptr SX' -> Ptr IndexList' -> Ptr IMatrix' -> Ptr SX' -> IO () casADi__Matrix_CasADi__SXElement___indexed_assignment''''' :: SX -> IndexList -> IMatrix -> SX -> IO () casADi__Matrix_CasADi__SXElement___indexed_assignment''''' x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> c_CasADi__Matrix_CasADi__SXElement___indexed_assignment_TIC_TIC_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn -- classy wrapper sx_indexed_assignment''''' :: SXClass a => a -> IndexList -> IMatrix -> SX -> IO () sx_indexed_assignment''''' x = casADi__Matrix_CasADi__SXElement___indexed_assignment''''' (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SXElement___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC :: Ptr SX' -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr SX' -> IO () casADi__Matrix_CasADi__SXElement___indexed_assignment'''''' :: SX -> IMatrix -> IMatrix -> SX -> IO () casADi__Matrix_CasADi__SXElement___indexed_assignment'''''' x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> c_CasADi__Matrix_CasADi__SXElement___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn -- classy wrapper sx_indexed_assignment'''''' :: SXClass a => a -> IMatrix -> IMatrix -> SX -> IO () sx_indexed_assignment'''''' x = casADi__Matrix_CasADi__SXElement___indexed_assignment'''''' (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SXElement___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC :: Ptr SX' -> Ptr Sparsity' -> Ptr SX' -> IO () casADi__Matrix_CasADi__SXElement___indexed_assignment''''''' :: SX -> Sparsity -> SX -> IO () casADi__Matrix_CasADi__SXElement___indexed_assignment''''''' x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_CasADi__SXElement___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' >>= wrapReturn -- classy wrapper sx_indexed_assignment''''''' :: SXClass a => a -> Sparsity -> SX -> IO () sx_indexed_assignment''''''' x = casADi__Matrix_CasADi__SXElement___indexed_assignment''''''' (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___indexed_one_based_assignment_TIC_TIC" c_CasADi__Matrix_CasADi__SXElement___indexed_one_based_assignment_TIC_TIC :: Ptr SX' -> CInt -> Ptr SXElement' -> IO () casADi__Matrix_CasADi__SXElement___indexed_one_based_assignment'' :: SX -> Int -> SXElement -> IO () casADi__Matrix_CasADi__SXElement___indexed_one_based_assignment'' x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_CasADi__SXElement___indexed_one_based_assignment_TIC_TIC x0' x1' x2' >>= wrapReturn -- classy wrapper sx_indexed_one_based_assignment'' :: SXClass a => a -> Int -> SXElement -> IO () sx_indexed_one_based_assignment'' x = casADi__Matrix_CasADi__SXElement___indexed_one_based_assignment'' (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___indexed_zero_based_assignment_TIC_TIC" c_CasADi__Matrix_CasADi__SXElement___indexed_zero_based_assignment_TIC_TIC :: Ptr SX' -> CInt -> Ptr SXElement' -> IO () casADi__Matrix_CasADi__SXElement___indexed_zero_based_assignment'' :: SX -> Int -> SXElement -> IO () casADi__Matrix_CasADi__SXElement___indexed_zero_based_assignment'' x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_CasADi__SXElement___indexed_zero_based_assignment_TIC_TIC x0' x1' x2' >>= wrapReturn -- classy wrapper sx_indexed_zero_based_assignment'' :: SXClass a => a -> Int -> SXElement -> IO () sx_indexed_zero_based_assignment'' x = casADi__Matrix_CasADi__SXElement___indexed_zero_based_assignment'' (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SXElement___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC :: Ptr SX' -> Ptr Slice' -> Ptr SX' -> IO () casADi__Matrix_CasADi__SXElement___indexed_assignment'''''''' :: SX -> Slice -> SX -> IO () casADi__Matrix_CasADi__SXElement___indexed_assignment'''''''' x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_CasADi__SXElement___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' >>= wrapReturn -- classy wrapper sx_indexed_assignment'''''''' :: SXClass a => a -> Slice -> SX -> IO () sx_indexed_assignment'''''''' x = casADi__Matrix_CasADi__SXElement___indexed_assignment'''''''' (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SXElement___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC :: Ptr SX' -> Ptr IndexList' -> Ptr SX' -> IO () casADi__Matrix_CasADi__SXElement___indexed_assignment''''''''' :: SX -> IndexList -> SX -> IO () casADi__Matrix_CasADi__SXElement___indexed_assignment''''''''' x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_CasADi__SXElement___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' >>= wrapReturn -- classy wrapper sx_indexed_assignment''''''''' :: SXClass a => a -> IndexList -> SX -> IO () sx_indexed_assignment''''''''' x = casADi__Matrix_CasADi__SXElement___indexed_assignment''''''''' (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___setZero" c_CasADi__Matrix_CasADi__SXElement___setZero :: Ptr SX' -> IO () casADi__Matrix_CasADi__SXElement___setZero :: SX -> IO () casADi__Matrix_CasADi__SXElement___setZero x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_CasADi__SXElement___setZero x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Set all elements >to zero. -} sx_setZero :: SXClass a => a -> IO () sx_setZero x = casADi__Matrix_CasADi__SXElement___setZero (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___setAll" c_CasADi__Matrix_CasADi__SXElement___setAll :: Ptr SX' -> Ptr SXElement' -> IO () casADi__Matrix_CasADi__SXElement___setAll :: SX -> SXElement -> IO () casADi__Matrix_CasADi__SXElement___setAll x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_CasADi__SXElement___setAll x0' x1' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Set all elements >to a value. -} sx_setAll :: SXClass a => a -> SXElement -> IO () sx_setAll x = casADi__Matrix_CasADi__SXElement___setAll (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___setSparse" c_CasADi__Matrix_CasADi__SXElement___setSparse :: Ptr SX' -> Ptr Sparsity' -> CInt -> IO (Ptr SX') casADi__Matrix_CasADi__SXElement___setSparse :: SX -> Sparsity -> Bool -> IO SX casADi__Matrix_CasADi__SXElement___setSparse x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_CasADi__SXElement___setSparse x0' x1' x2' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Set sparse. -} sx_setSparse :: SXClass a => a -> Sparsity -> Bool -> IO SX sx_setSparse x = casADi__Matrix_CasADi__SXElement___setSparse (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___setSparse_TIC" c_CasADi__Matrix_CasADi__SXElement___setSparse_TIC :: Ptr SX' -> Ptr Sparsity' -> IO (Ptr SX') casADi__Matrix_CasADi__SXElement___setSparse' :: SX -> Sparsity -> IO SX casADi__Matrix_CasADi__SXElement___setSparse' x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_CasADi__SXElement___setSparse_TIC x0' x1' >>= wrapReturn -- classy wrapper sx_setSparse' :: SXClass a => a -> Sparsity -> IO SX sx_setSparse' x = casADi__Matrix_CasADi__SXElement___setSparse' (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___densify" c_CasADi__Matrix_CasADi__SXElement___densify :: Ptr SX' -> Ptr SXElement' -> IO () casADi__Matrix_CasADi__SXElement___densify :: SX -> SXElement -> IO () casADi__Matrix_CasADi__SXElement___densify x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_CasADi__SXElement___densify x0' x1' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Make the matrix >dense. -} sx_densify :: SXClass a => a -> SXElement -> IO () sx_densify x = casADi__Matrix_CasADi__SXElement___densify (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___densify_TIC" c_CasADi__Matrix_CasADi__SXElement___densify_TIC :: Ptr SX' -> IO () casADi__Matrix_CasADi__SXElement___densify' :: SX -> IO () casADi__Matrix_CasADi__SXElement___densify' x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_CasADi__SXElement___densify_TIC x0' >>= wrapReturn -- classy wrapper sx_densify' :: SXClass a => a -> IO () sx_densify' x = casADi__Matrix_CasADi__SXElement___densify' (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___sparsify" c_CasADi__Matrix_CasADi__SXElement___sparsify :: Ptr SX' -> CDouble -> IO () casADi__Matrix_CasADi__SXElement___sparsify :: SX -> Double -> IO () casADi__Matrix_CasADi__SXElement___sparsify x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_CasADi__SXElement___sparsify x0' x1' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Make a matrix >sparse by removing numerical zeros smaller in absolute value than a >specified tolerance. -} sx_sparsify :: SXClass a => a -> Double -> IO () sx_sparsify x = casADi__Matrix_CasADi__SXElement___sparsify (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___sparsify_TIC" c_CasADi__Matrix_CasADi__SXElement___sparsify_TIC :: Ptr SX' -> IO () casADi__Matrix_CasADi__SXElement___sparsify' :: SX -> IO () casADi__Matrix_CasADi__SXElement___sparsify' x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_CasADi__SXElement___sparsify_TIC x0' >>= wrapReturn -- classy wrapper sx_sparsify' :: SXClass a => a -> IO () sx_sparsify' x = casADi__Matrix_CasADi__SXElement___sparsify' (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___operator_plus" c_CasADi__Matrix_CasADi__SXElement___operator_plus :: Ptr SX' -> IO (Ptr SX') casADi__Matrix_CasADi__SXElement___operator_plus :: SX -> IO SX casADi__Matrix_CasADi__SXElement___operator_plus x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_CasADi__SXElement___operator_plus x0' >>= wrapReturn -- classy wrapper sx_operator_plus :: SXClass a => a -> IO SX sx_operator_plus x = casADi__Matrix_CasADi__SXElement___operator_plus (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___operator_minus" c_CasADi__Matrix_CasADi__SXElement___operator_minus :: Ptr SX' -> IO (Ptr SX') casADi__Matrix_CasADi__SXElement___operator_minus :: SX -> IO SX casADi__Matrix_CasADi__SXElement___operator_minus x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_CasADi__SXElement___operator_minus x0' >>= wrapReturn -- classy wrapper sx_operator_minus :: SXClass a => a -> IO SX sx_operator_minus x = casADi__Matrix_CasADi__SXElement___operator_minus (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___binary" c_CasADi__Matrix_CasADi__SXElement___binary :: CInt -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') casADi__Matrix_CasADi__SXElement___binary :: Int -> SX -> SX -> IO SX casADi__Matrix_CasADi__SXElement___binary x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_CasADi__SXElement___binary x0' x1' x2' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Create nodes by >their ID. -} sx_binary :: Int -> SX -> SX -> IO SX sx_binary = casADi__Matrix_CasADi__SXElement___binary -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___unary" c_CasADi__Matrix_CasADi__SXElement___unary :: CInt -> Ptr SX' -> IO (Ptr SX') casADi__Matrix_CasADi__SXElement___unary :: Int -> SX -> IO SX casADi__Matrix_CasADi__SXElement___unary x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_CasADi__SXElement___unary x0' x1' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Create nodes by >their ID. -} sx_unary :: Int -> SX -> IO SX sx_unary = casADi__Matrix_CasADi__SXElement___unary -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___scalar_matrix" c_CasADi__Matrix_CasADi__SXElement___scalar_matrix :: CInt -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') casADi__Matrix_CasADi__SXElement___scalar_matrix :: Int -> SX -> SX -> IO SX casADi__Matrix_CasADi__SXElement___scalar_matrix x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_CasADi__SXElement___scalar_matrix x0' x1' x2' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Create >nodes by their ID. -} sx_scalar_matrix :: Int -> SX -> SX -> IO SX sx_scalar_matrix = casADi__Matrix_CasADi__SXElement___scalar_matrix -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___matrix_scalar" c_CasADi__Matrix_CasADi__SXElement___matrix_scalar :: CInt -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') casADi__Matrix_CasADi__SXElement___matrix_scalar :: Int -> SX -> SX -> IO SX casADi__Matrix_CasADi__SXElement___matrix_scalar x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_CasADi__SXElement___matrix_scalar x0' x1' x2' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Create >nodes by their ID. -} sx_matrix_scalar :: Int -> SX -> SX -> IO SX sx_matrix_scalar = casADi__Matrix_CasADi__SXElement___matrix_scalar -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___matrix_matrix" c_CasADi__Matrix_CasADi__SXElement___matrix_matrix :: CInt -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') casADi__Matrix_CasADi__SXElement___matrix_matrix :: Int -> SX -> SX -> IO SX casADi__Matrix_CasADi__SXElement___matrix_matrix x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_CasADi__SXElement___matrix_matrix x0' x1' x2' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Create >nodes by their ID. -} sx_matrix_matrix :: Int -> SX -> SX -> IO SX sx_matrix_matrix = casADi__Matrix_CasADi__SXElement___matrix_matrix -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement_____add__" c_CasADi__Matrix_CasADi__SXElement_____add__ :: Ptr SX' -> Ptr SX' -> IO (Ptr SX') casADi__Matrix_CasADi__SXElement_____add__ :: SX -> SX -> IO SX casADi__Matrix_CasADi__SXElement_____add__ x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_CasADi__SXElement_____add__ x0' x1' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Elementwise >operations Octave/Python naming. -} sx___add__ :: SXClass a => a -> SX -> IO SX sx___add__ x = casADi__Matrix_CasADi__SXElement_____add__ (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement_____sub__" c_CasADi__Matrix_CasADi__SXElement_____sub__ :: Ptr SX' -> Ptr SX' -> IO (Ptr SX') casADi__Matrix_CasADi__SXElement_____sub__ :: SX -> SX -> IO SX casADi__Matrix_CasADi__SXElement_____sub__ x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_CasADi__SXElement_____sub__ x0' x1' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Elementwise >operations Octave/Python naming. -} sx___sub__ :: SXClass a => a -> SX -> IO SX sx___sub__ x = casADi__Matrix_CasADi__SXElement_____sub__ (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement_____mul__" c_CasADi__Matrix_CasADi__SXElement_____mul__ :: Ptr SX' -> Ptr SX' -> IO (Ptr SX') casADi__Matrix_CasADi__SXElement_____mul__ :: SX -> SX -> IO SX casADi__Matrix_CasADi__SXElement_____mul__ x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_CasADi__SXElement_____mul__ x0' x1' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Elementwise >operations Octave/Python naming. -} sx___mul__ :: SXClass a => a -> SX -> IO SX sx___mul__ x = casADi__Matrix_CasADi__SXElement_____mul__ (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement_____div__" c_CasADi__Matrix_CasADi__SXElement_____div__ :: Ptr SX' -> Ptr SX' -> IO (Ptr SX') casADi__Matrix_CasADi__SXElement_____div__ :: SX -> SX -> IO SX casADi__Matrix_CasADi__SXElement_____div__ x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_CasADi__SXElement_____div__ x0' x1' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Elementwise >operations Octave/Python naming. -} sx___div__ :: SXClass a => a -> SX -> IO SX sx___div__ x = casADi__Matrix_CasADi__SXElement_____div__ (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement_____lt__" c_CasADi__Matrix_CasADi__SXElement_____lt__ :: Ptr SX' -> Ptr SX' -> IO (Ptr SX') casADi__Matrix_CasADi__SXElement_____lt__ :: SX -> SX -> IO SX casADi__Matrix_CasADi__SXElement_____lt__ x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_CasADi__SXElement_____lt__ x0' x1' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Elementwise >operations Octave/Python naming. -} sx___lt__ :: SXClass a => a -> SX -> IO SX sx___lt__ x = casADi__Matrix_CasADi__SXElement_____lt__ (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement_____le__" c_CasADi__Matrix_CasADi__SXElement_____le__ :: Ptr SX' -> Ptr SX' -> IO (Ptr SX') casADi__Matrix_CasADi__SXElement_____le__ :: SX -> SX -> IO SX casADi__Matrix_CasADi__SXElement_____le__ x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_CasADi__SXElement_____le__ x0' x1' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Elementwise >operations Octave/Python naming. -} sx___le__ :: SXClass a => a -> SX -> IO SX sx___le__ x = casADi__Matrix_CasADi__SXElement_____le__ (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement_____eq__" c_CasADi__Matrix_CasADi__SXElement_____eq__ :: Ptr SX' -> Ptr SX' -> IO (Ptr SX') casADi__Matrix_CasADi__SXElement_____eq__ :: SX -> SX -> IO SX casADi__Matrix_CasADi__SXElement_____eq__ x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_CasADi__SXElement_____eq__ x0' x1' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Elementwise >operations Octave/Python naming. -} sx___eq__ :: SXClass a => a -> SX -> IO SX sx___eq__ x = casADi__Matrix_CasADi__SXElement_____eq__ (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement_____ne__" c_CasADi__Matrix_CasADi__SXElement_____ne__ :: Ptr SX' -> Ptr SX' -> IO (Ptr SX') casADi__Matrix_CasADi__SXElement_____ne__ :: SX -> SX -> IO SX casADi__Matrix_CasADi__SXElement_____ne__ x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_CasADi__SXElement_____ne__ x0' x1' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Elementwise >operations Octave/Python naming. -} sx___ne__ :: SXClass a => a -> SX -> IO SX sx___ne__ x = casADi__Matrix_CasADi__SXElement_____ne__ (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement_____truediv__" c_CasADi__Matrix_CasADi__SXElement_____truediv__ :: Ptr SX' -> Ptr SX' -> IO (Ptr SX') casADi__Matrix_CasADi__SXElement_____truediv__ :: SX -> SX -> IO SX casADi__Matrix_CasADi__SXElement_____truediv__ x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_CasADi__SXElement_____truediv__ x0' x1' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Elementwise >operations Octave/Python naming. -} sx___truediv__ :: SXClass a => a -> SX -> IO SX sx___truediv__ x = casADi__Matrix_CasADi__SXElement_____truediv__ (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement_____pow__" c_CasADi__Matrix_CasADi__SXElement_____pow__ :: Ptr SX' -> Ptr SX' -> IO (Ptr SX') casADi__Matrix_CasADi__SXElement_____pow__ :: SX -> SX -> IO SX casADi__Matrix_CasADi__SXElement_____pow__ x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_CasADi__SXElement_____pow__ x0' x1' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Elementwise >operations Octave/Python naming. -} sx___pow__ :: SXClass a => a -> SX -> IO SX sx___pow__ x = casADi__Matrix_CasADi__SXElement_____pow__ (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement_____constpow__" c_CasADi__Matrix_CasADi__SXElement_____constpow__ :: Ptr SX' -> Ptr SX' -> IO (Ptr SX') casADi__Matrix_CasADi__SXElement_____constpow__ :: SX -> SX -> IO SX casADi__Matrix_CasADi__SXElement_____constpow__ x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_CasADi__SXElement_____constpow__ x0' x1' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Elementwise >operations Octave/Python naming. -} sx___constpow__ :: SXClass a => a -> SX -> IO SX sx___constpow__ x = casADi__Matrix_CasADi__SXElement_____constpow__ (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement_____mpower__" c_CasADi__Matrix_CasADi__SXElement_____mpower__ :: Ptr SX' -> Ptr SX' -> IO (Ptr SX') casADi__Matrix_CasADi__SXElement_____mpower__ :: SX -> SX -> IO SX casADi__Matrix_CasADi__SXElement_____mpower__ x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_CasADi__SXElement_____mpower__ x0' x1' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Elementwise >operations Octave/Python naming. -} sx___mpower__ :: SXClass a => a -> SX -> IO SX sx___mpower__ x = casADi__Matrix_CasADi__SXElement_____mpower__ (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement_____mrdivide__" c_CasADi__Matrix_CasADi__SXElement_____mrdivide__ :: Ptr SX' -> Ptr SX' -> IO (Ptr SX') casADi__Matrix_CasADi__SXElement_____mrdivide__ :: SX -> SX -> IO SX casADi__Matrix_CasADi__SXElement_____mrdivide__ x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_CasADi__SXElement_____mrdivide__ x0' x1' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Elementwise >operations Octave/Python naming. -} sx___mrdivide__ :: SXClass a => a -> SX -> IO SX sx___mrdivide__ x = casADi__Matrix_CasADi__SXElement_____mrdivide__ (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___mul_full" c_CasADi__Matrix_CasADi__SXElement___mul_full :: Ptr SX' -> Ptr SX' -> Ptr Sparsity' -> IO (Ptr SX') casADi__Matrix_CasADi__SXElement___mul_full :: SX -> SX -> Sparsity -> IO SX casADi__Matrix_CasADi__SXElement___mul_full x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_CasADi__SXElement___mul_full x0' x1' x2' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Matrix-matrix >product. -} sx_mul_full :: SXClass a => a -> SX -> Sparsity -> IO SX sx_mul_full x = casADi__Matrix_CasADi__SXElement___mul_full (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___mul_full_TIC" c_CasADi__Matrix_CasADi__SXElement___mul_full_TIC :: Ptr SX' -> Ptr SX' -> IO (Ptr SX') casADi__Matrix_CasADi__SXElement___mul_full' :: SX -> SX -> IO SX casADi__Matrix_CasADi__SXElement___mul_full' x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_CasADi__SXElement___mul_full_TIC x0' x1' >>= wrapReturn -- classy wrapper sx_mul_full' :: SXClass a => a -> SX -> IO SX sx_mul_full' x = casADi__Matrix_CasADi__SXElement___mul_full' (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___mul" c_CasADi__Matrix_CasADi__SXElement___mul :: Ptr SX' -> Ptr SX' -> Ptr Sparsity' -> IO (Ptr SX') casADi__Matrix_CasADi__SXElement___mul :: SX -> SX -> Sparsity -> IO SX casADi__Matrix_CasADi__SXElement___mul x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_CasADi__SXElement___mul x0' x1' x2' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Matrix-matrix >product. -} sx_mul :: SXClass a => a -> SX -> Sparsity -> IO SX sx_mul x = casADi__Matrix_CasADi__SXElement___mul (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___mul_TIC" c_CasADi__Matrix_CasADi__SXElement___mul_TIC :: Ptr SX' -> Ptr SX' -> IO (Ptr SX') casADi__Matrix_CasADi__SXElement___mul' :: SX -> SX -> IO SX casADi__Matrix_CasADi__SXElement___mul' x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_CasADi__SXElement___mul_TIC x0' x1' >>= wrapReturn -- classy wrapper sx_mul' :: SXClass a => a -> SX -> IO SX sx_mul' x = casADi__Matrix_CasADi__SXElement___mul' (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___mul_no_alloc_nn" c_CasADi__Matrix_CasADi__SXElement___mul_no_alloc_nn :: Ptr SX' -> Ptr SX' -> Ptr SX' -> IO () casADi__Matrix_CasADi__SXElement___mul_no_alloc_nn :: SX -> SX -> SX -> IO () casADi__Matrix_CasADi__SXElement___mul_no_alloc_nn x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_CasADi__SXElement___mul_no_alloc_nn x0' x1' x2' >>= wrapReturn -- classy wrapper sx_mul_no_alloc_nn :: SX -> SX -> SX -> IO () sx_mul_no_alloc_nn = casADi__Matrix_CasADi__SXElement___mul_no_alloc_nn -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___mul_no_alloc_tn" c_CasADi__Matrix_CasADi__SXElement___mul_no_alloc_tn :: Ptr SX' -> Ptr SX' -> Ptr SX' -> IO () casADi__Matrix_CasADi__SXElement___mul_no_alloc_tn :: SX -> SX -> SX -> IO () casADi__Matrix_CasADi__SXElement___mul_no_alloc_tn x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_CasADi__SXElement___mul_no_alloc_tn x0' x1' x2' >>= wrapReturn -- classy wrapper sx_mul_no_alloc_tn :: SX -> SX -> SX -> IO () sx_mul_no_alloc_tn = casADi__Matrix_CasADi__SXElement___mul_no_alloc_tn -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___mul_no_alloc_nt" c_CasADi__Matrix_CasADi__SXElement___mul_no_alloc_nt :: Ptr SX' -> Ptr SX' -> Ptr SX' -> IO () casADi__Matrix_CasADi__SXElement___mul_no_alloc_nt :: SX -> SX -> SX -> IO () casADi__Matrix_CasADi__SXElement___mul_no_alloc_nt x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_CasADi__SXElement___mul_no_alloc_nt x0' x1' x2' >>= wrapReturn -- classy wrapper sx_mul_no_alloc_nt :: SX -> SX -> SX -> IO () sx_mul_no_alloc_nt = casADi__Matrix_CasADi__SXElement___mul_no_alloc_nt -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___mul_no_alloc_tn_TIC" c_CasADi__Matrix_CasADi__SXElement___mul_no_alloc_tn_TIC :: Ptr SX' -> Ptr (CppVec (Ptr SXElement')) -> Ptr (CppVec (Ptr SXElement')) -> IO () casADi__Matrix_CasADi__SXElement___mul_no_alloc_tn' :: SX -> Vector SXElement -> Vector SXElement -> IO () casADi__Matrix_CasADi__SXElement___mul_no_alloc_tn' x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_CasADi__SXElement___mul_no_alloc_tn_TIC x0' x1' x2' >>= wrapReturn -- classy wrapper sx_mul_no_alloc_tn' :: SX -> Vector SXElement -> Vector SXElement -> IO () sx_mul_no_alloc_tn' = casADi__Matrix_CasADi__SXElement___mul_no_alloc_tn' -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___mul_no_alloc_nn_TIC" c_CasADi__Matrix_CasADi__SXElement___mul_no_alloc_nn_TIC :: Ptr SX' -> Ptr (CppVec (Ptr SXElement')) -> Ptr (CppVec (Ptr SXElement')) -> IO () casADi__Matrix_CasADi__SXElement___mul_no_alloc_nn' :: SX -> Vector SXElement -> Vector SXElement -> IO () casADi__Matrix_CasADi__SXElement___mul_no_alloc_nn' x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_CasADi__SXElement___mul_no_alloc_nn_TIC x0' x1' x2' >>= wrapReturn -- classy wrapper sx_mul_no_alloc_nn' :: SX -> Vector SXElement -> Vector SXElement -> IO () sx_mul_no_alloc_nn' = casADi__Matrix_CasADi__SXElement___mul_no_alloc_nn' -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___quad_form" c_CasADi__Matrix_CasADi__SXElement___quad_form :: Ptr SX' -> Ptr (CppVec (Ptr SXElement')) -> IO (Ptr SXElement') casADi__Matrix_CasADi__SXElement___quad_form :: SX -> Vector SXElement -> IO SXElement casADi__Matrix_CasADi__SXElement___quad_form x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_CasADi__SXElement___quad_form x0' x1' >>= wrapReturn -- classy wrapper sx_quad_form :: SX -> Vector SXElement -> IO SXElement sx_quad_form = casADi__Matrix_CasADi__SXElement___quad_form -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___trans" c_CasADi__Matrix_CasADi__SXElement___trans :: Ptr SX' -> IO (Ptr SX') casADi__Matrix_CasADi__SXElement___trans :: SX -> IO SX casADi__Matrix_CasADi__SXElement___trans x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_CasADi__SXElement___trans x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Transpose the >matrix. -} sx_trans :: SXClass a => a -> IO SX sx_trans x = casADi__Matrix_CasADi__SXElement___trans (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___sin" c_CasADi__Matrix_CasADi__SXElement___sin :: Ptr SX' -> IO (Ptr SX') casADi__Matrix_CasADi__SXElement___sin :: SX -> IO SX casADi__Matrix_CasADi__SXElement___sin x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_CasADi__SXElement___sin x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Operations defined >in the standard namespace for unambigous access and Numpy compatibility. -} sx_sin :: SXClass a => a -> IO SX sx_sin x = casADi__Matrix_CasADi__SXElement___sin (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___cos" c_CasADi__Matrix_CasADi__SXElement___cos :: Ptr SX' -> IO (Ptr SX') casADi__Matrix_CasADi__SXElement___cos :: SX -> IO SX casADi__Matrix_CasADi__SXElement___cos x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_CasADi__SXElement___cos x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Operations defined >in the standard namespace for unambigous access and Numpy compatibility. -} sx_cos :: SXClass a => a -> IO SX sx_cos x = casADi__Matrix_CasADi__SXElement___cos (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___tan" c_CasADi__Matrix_CasADi__SXElement___tan :: Ptr SX' -> IO (Ptr SX') casADi__Matrix_CasADi__SXElement___tan :: SX -> IO SX casADi__Matrix_CasADi__SXElement___tan x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_CasADi__SXElement___tan x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Operations defined >in the standard namespace for unambigous access and Numpy compatibility. -} sx_tan :: SXClass a => a -> IO SX sx_tan x = casADi__Matrix_CasADi__SXElement___tan (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___arcsin" c_CasADi__Matrix_CasADi__SXElement___arcsin :: Ptr SX' -> IO (Ptr SX') casADi__Matrix_CasADi__SXElement___arcsin :: SX -> IO SX casADi__Matrix_CasADi__SXElement___arcsin x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_CasADi__SXElement___arcsin x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Operations >defined in the standard namespace for unambigous access and Numpy >compatibility. -} sx_arcsin :: SXClass a => a -> IO SX sx_arcsin x = casADi__Matrix_CasADi__SXElement___arcsin (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___arccos" c_CasADi__Matrix_CasADi__SXElement___arccos :: Ptr SX' -> IO (Ptr SX') casADi__Matrix_CasADi__SXElement___arccos :: SX -> IO SX casADi__Matrix_CasADi__SXElement___arccos x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_CasADi__SXElement___arccos x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Operations >defined in the standard namespace for unambigous access and Numpy >compatibility. -} sx_arccos :: SXClass a => a -> IO SX sx_arccos x = casADi__Matrix_CasADi__SXElement___arccos (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___arctan" c_CasADi__Matrix_CasADi__SXElement___arctan :: Ptr SX' -> IO (Ptr SX') casADi__Matrix_CasADi__SXElement___arctan :: SX -> IO SX casADi__Matrix_CasADi__SXElement___arctan x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_CasADi__SXElement___arctan x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Operations >defined in the standard namespace for unambigous access and Numpy >compatibility. -} sx_arctan :: SXClass a => a -> IO SX sx_arctan x = casADi__Matrix_CasADi__SXElement___arctan (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___exp" c_CasADi__Matrix_CasADi__SXElement___exp :: Ptr SX' -> IO (Ptr SX') casADi__Matrix_CasADi__SXElement___exp :: SX -> IO SX casADi__Matrix_CasADi__SXElement___exp x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_CasADi__SXElement___exp x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Operations defined >in the standard namespace for unambigous access and Numpy compatibility. -} sx_exp :: SXClass a => a -> IO SX sx_exp x = casADi__Matrix_CasADi__SXElement___exp (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___log" c_CasADi__Matrix_CasADi__SXElement___log :: Ptr SX' -> IO (Ptr SX') casADi__Matrix_CasADi__SXElement___log :: SX -> IO SX casADi__Matrix_CasADi__SXElement___log x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_CasADi__SXElement___log x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Operations defined >in the standard namespace for unambigous access and Numpy compatibility. -} sx_log :: SXClass a => a -> IO SX sx_log x = casADi__Matrix_CasADi__SXElement___log (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___sqrt" c_CasADi__Matrix_CasADi__SXElement___sqrt :: Ptr SX' -> IO (Ptr SX') casADi__Matrix_CasADi__SXElement___sqrt :: SX -> IO SX casADi__Matrix_CasADi__SXElement___sqrt x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_CasADi__SXElement___sqrt x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Operations defined >in the standard namespace for unambigous access and Numpy compatibility. -} sx_sqrt :: SXClass a => a -> IO SX sx_sqrt x = casADi__Matrix_CasADi__SXElement___sqrt (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___floor" c_CasADi__Matrix_CasADi__SXElement___floor :: Ptr SX' -> IO (Ptr SX') casADi__Matrix_CasADi__SXElement___floor :: SX -> IO SX casADi__Matrix_CasADi__SXElement___floor x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_CasADi__SXElement___floor x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Operations defined >in the standard namespace for unambigous access and Numpy compatibility. -} sx_floor :: SXClass a => a -> IO SX sx_floor x = casADi__Matrix_CasADi__SXElement___floor (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___ceil" c_CasADi__Matrix_CasADi__SXElement___ceil :: Ptr SX' -> IO (Ptr SX') casADi__Matrix_CasADi__SXElement___ceil :: SX -> IO SX casADi__Matrix_CasADi__SXElement___ceil x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_CasADi__SXElement___ceil x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Operations defined >in the standard namespace for unambigous access and Numpy compatibility. -} sx_ceil :: SXClass a => a -> IO SX sx_ceil x = casADi__Matrix_CasADi__SXElement___ceil (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___fabs" c_CasADi__Matrix_CasADi__SXElement___fabs :: Ptr SX' -> IO (Ptr SX') casADi__Matrix_CasADi__SXElement___fabs :: SX -> IO SX casADi__Matrix_CasADi__SXElement___fabs x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_CasADi__SXElement___fabs x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Operations defined >in the standard namespace for unambigous access and Numpy compatibility. -} sx_fabs :: SXClass a => a -> IO SX sx_fabs x = casADi__Matrix_CasADi__SXElement___fabs (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___sign" c_CasADi__Matrix_CasADi__SXElement___sign :: Ptr SX' -> IO (Ptr SX') casADi__Matrix_CasADi__SXElement___sign :: SX -> IO SX casADi__Matrix_CasADi__SXElement___sign x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_CasADi__SXElement___sign x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Operations defined >in the standard namespace for unambigous access and Numpy compatibility. -} sx_sign :: SXClass a => a -> IO SX sx_sign x = casADi__Matrix_CasADi__SXElement___sign (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement_____copysign__" c_CasADi__Matrix_CasADi__SXElement_____copysign__ :: Ptr SX' -> Ptr SX' -> IO (Ptr SX') casADi__Matrix_CasADi__SXElement_____copysign__ :: SX -> SX -> IO SX casADi__Matrix_CasADi__SXElement_____copysign__ x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_CasADi__SXElement_____copysign__ x0' x1' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Operations >defined in the standard namespace for unambigous access and Numpy >compatibility. -} sx___copysign__ :: SXClass a => a -> SX -> IO SX sx___copysign__ x = casADi__Matrix_CasADi__SXElement_____copysign__ (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___erfinv" c_CasADi__Matrix_CasADi__SXElement___erfinv :: Ptr SX' -> IO (Ptr SX') casADi__Matrix_CasADi__SXElement___erfinv :: SX -> IO SX casADi__Matrix_CasADi__SXElement___erfinv x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_CasADi__SXElement___erfinv x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Operations >defined in the standard namespace for unambigous access and Numpy >compatibility. -} sx_erfinv :: SXClass a => a -> IO SX sx_erfinv x = casADi__Matrix_CasADi__SXElement___erfinv (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___fmin" c_CasADi__Matrix_CasADi__SXElement___fmin :: Ptr SX' -> Ptr SX' -> IO (Ptr SX') casADi__Matrix_CasADi__SXElement___fmin :: SX -> SX -> IO SX casADi__Matrix_CasADi__SXElement___fmin x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_CasADi__SXElement___fmin x0' x1' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Operations defined >in the standard namespace for unambigous access and Numpy compatibility. -} sx_fmin :: SXClass a => a -> SX -> IO SX sx_fmin x = casADi__Matrix_CasADi__SXElement___fmin (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___fmax" c_CasADi__Matrix_CasADi__SXElement___fmax :: Ptr SX' -> Ptr SX' -> IO (Ptr SX') casADi__Matrix_CasADi__SXElement___fmax :: SX -> SX -> IO SX casADi__Matrix_CasADi__SXElement___fmax x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_CasADi__SXElement___fmax x0' x1' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Operations defined >in the standard namespace for unambigous access and Numpy compatibility. -} sx_fmax :: SXClass a => a -> SX -> IO SX sx_fmax x = casADi__Matrix_CasADi__SXElement___fmax (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___erf" c_CasADi__Matrix_CasADi__SXElement___erf :: Ptr SX' -> IO (Ptr SX') casADi__Matrix_CasADi__SXElement___erf :: SX -> IO SX casADi__Matrix_CasADi__SXElement___erf x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_CasADi__SXElement___erf x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Operations defined >in the standard namespace for unambigous access and Numpy compatibility. -} sx_erf :: SXClass a => a -> IO SX sx_erf x = casADi__Matrix_CasADi__SXElement___erf (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___sinh" c_CasADi__Matrix_CasADi__SXElement___sinh :: Ptr SX' -> IO (Ptr SX') casADi__Matrix_CasADi__SXElement___sinh :: SX -> IO SX casADi__Matrix_CasADi__SXElement___sinh x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_CasADi__SXElement___sinh x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Operations defined >in the standard namespace for unambigous access and Numpy compatibility. -} sx_sinh :: SXClass a => a -> IO SX sx_sinh x = casADi__Matrix_CasADi__SXElement___sinh (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___cosh" c_CasADi__Matrix_CasADi__SXElement___cosh :: Ptr SX' -> IO (Ptr SX') casADi__Matrix_CasADi__SXElement___cosh :: SX -> IO SX casADi__Matrix_CasADi__SXElement___cosh x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_CasADi__SXElement___cosh x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Operations defined >in the standard namespace for unambigous access and Numpy compatibility. -} sx_cosh :: SXClass a => a -> IO SX sx_cosh x = casADi__Matrix_CasADi__SXElement___cosh (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___tanh" c_CasADi__Matrix_CasADi__SXElement___tanh :: Ptr SX' -> IO (Ptr SX') casADi__Matrix_CasADi__SXElement___tanh :: SX -> IO SX casADi__Matrix_CasADi__SXElement___tanh x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_CasADi__SXElement___tanh x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Operations defined >in the standard namespace for unambigous access and Numpy compatibility. -} sx_tanh :: SXClass a => a -> IO SX sx_tanh x = casADi__Matrix_CasADi__SXElement___tanh (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___arcsinh" c_CasADi__Matrix_CasADi__SXElement___arcsinh :: Ptr SX' -> IO (Ptr SX') casADi__Matrix_CasADi__SXElement___arcsinh :: SX -> IO SX casADi__Matrix_CasADi__SXElement___arcsinh x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_CasADi__SXElement___arcsinh x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Operations >defined in the standard namespace for unambigous access and Numpy >compatibility. -} sx_arcsinh :: SXClass a => a -> IO SX sx_arcsinh x = casADi__Matrix_CasADi__SXElement___arcsinh (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___arccosh" c_CasADi__Matrix_CasADi__SXElement___arccosh :: Ptr SX' -> IO (Ptr SX') casADi__Matrix_CasADi__SXElement___arccosh :: SX -> IO SX casADi__Matrix_CasADi__SXElement___arccosh x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_CasADi__SXElement___arccosh x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Operations >defined in the standard namespace for unambigous access and Numpy >compatibility. -} sx_arccosh :: SXClass a => a -> IO SX sx_arccosh x = casADi__Matrix_CasADi__SXElement___arccosh (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___arctanh" c_CasADi__Matrix_CasADi__SXElement___arctanh :: Ptr SX' -> IO (Ptr SX') casADi__Matrix_CasADi__SXElement___arctanh :: SX -> IO SX casADi__Matrix_CasADi__SXElement___arctanh x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_CasADi__SXElement___arctanh x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Operations >defined in the standard namespace for unambigous access and Numpy >compatibility. -} sx_arctanh :: SXClass a => a -> IO SX sx_arctanh x = casADi__Matrix_CasADi__SXElement___arctanh (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___arctan2" c_CasADi__Matrix_CasADi__SXElement___arctan2 :: Ptr SX' -> Ptr SX' -> IO (Ptr SX') casADi__Matrix_CasADi__SXElement___arctan2 :: SX -> SX -> IO SX casADi__Matrix_CasADi__SXElement___arctan2 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_CasADi__SXElement___arctan2 x0' x1' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Operations >defined in the standard namespace for unambigous access and Numpy >compatibility. -} sx_arctan2 :: SXClass a => a -> SX -> IO SX sx_arctan2 x = casADi__Matrix_CasADi__SXElement___arctan2 (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___log10" c_CasADi__Matrix_CasADi__SXElement___log10 :: Ptr SX' -> IO (Ptr SX') casADi__Matrix_CasADi__SXElement___log10 :: SX -> IO SX casADi__Matrix_CasADi__SXElement___log10 x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_CasADi__SXElement___log10 x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Operations defined >in the standard namespace for unambigous access and Numpy compatibility. -} sx_log10 :: SXClass a => a -> IO SX sx_log10 x = casADi__Matrix_CasADi__SXElement___log10 (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___printme" c_CasADi__Matrix_CasADi__SXElement___printme :: Ptr SX' -> Ptr SX' -> IO (Ptr SX') casADi__Matrix_CasADi__SXElement___printme :: SX -> SX -> IO SX casADi__Matrix_CasADi__SXElement___printme x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_CasADi__SXElement___printme x0' x1' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Operations >defined in the standard namespace for unambigous access and Numpy >compatibility. -} sx_printme :: SXClass a => a -> SX -> IO SX sx_printme x = casADi__Matrix_CasADi__SXElement___printme (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___logic_not" c_CasADi__Matrix_CasADi__SXElement___logic_not :: Ptr SX' -> IO (Ptr SX') casADi__Matrix_CasADi__SXElement___logic_not :: SX -> IO SX casADi__Matrix_CasADi__SXElement___logic_not x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_CasADi__SXElement___logic_not x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Operations >defined in the standard namespace for unambigous access and Numpy >compatibility. -} sx_logic_not :: SXClass a => a -> IO SX sx_logic_not x = casADi__Matrix_CasADi__SXElement___logic_not (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___logic_and" c_CasADi__Matrix_CasADi__SXElement___logic_and :: Ptr SX' -> Ptr SX' -> IO (Ptr SX') casADi__Matrix_CasADi__SXElement___logic_and :: SX -> SX -> IO SX casADi__Matrix_CasADi__SXElement___logic_and x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_CasADi__SXElement___logic_and x0' x1' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Operations >defined in the standard namespace for unambigous access and Numpy >compatibility. -} sx_logic_and :: SXClass a => a -> SX -> IO SX sx_logic_and x = casADi__Matrix_CasADi__SXElement___logic_and (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___logic_or" c_CasADi__Matrix_CasADi__SXElement___logic_or :: Ptr SX' -> Ptr SX' -> IO (Ptr SX') casADi__Matrix_CasADi__SXElement___logic_or :: SX -> SX -> IO SX casADi__Matrix_CasADi__SXElement___logic_or x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_CasADi__SXElement___logic_or x0' x1' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Operations >defined in the standard namespace for unambigous access and Numpy >compatibility. -} sx_logic_or :: SXClass a => a -> SX -> IO SX sx_logic_or x = casADi__Matrix_CasADi__SXElement___logic_or (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___if_else_zero" c_CasADi__Matrix_CasADi__SXElement___if_else_zero :: Ptr SX' -> Ptr SX' -> IO (Ptr SX') casADi__Matrix_CasADi__SXElement___if_else_zero :: SX -> SX -> IO SX casADi__Matrix_CasADi__SXElement___if_else_zero x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_CasADi__SXElement___if_else_zero x0' x1' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Operations >defined in the standard namespace for unambigous access and Numpy >compatibility. -} sx_if_else_zero :: SXClass a => a -> SX -> IO SX sx_if_else_zero x = casADi__Matrix_CasADi__SXElement___if_else_zero (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___setMaxNumCallsInPrint" c_CasADi__Matrix_CasADi__SXElement___setMaxNumCallsInPrint :: CLong -> IO () casADi__Matrix_CasADi__SXElement___setMaxNumCallsInPrint :: Int -> IO () casADi__Matrix_CasADi__SXElement___setMaxNumCallsInPrint x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_CasADi__SXElement___setMaxNumCallsInPrint x0' >>= wrapReturn -- classy wrapper sx_setMaxNumCallsInPrint :: Int -> IO () sx_setMaxNumCallsInPrint = casADi__Matrix_CasADi__SXElement___setMaxNumCallsInPrint -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___setMaxNumCallsInPrint_TIC" c_CasADi__Matrix_CasADi__SXElement___setMaxNumCallsInPrint_TIC :: IO () casADi__Matrix_CasADi__SXElement___setMaxNumCallsInPrint' :: IO () casADi__Matrix_CasADi__SXElement___setMaxNumCallsInPrint' = c_CasADi__Matrix_CasADi__SXElement___setMaxNumCallsInPrint_TIC >>= wrapReturn -- classy wrapper sx_setMaxNumCallsInPrint' :: IO () sx_setMaxNumCallsInPrint' = casADi__Matrix_CasADi__SXElement___setMaxNumCallsInPrint' -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___getMaxNumCallsInPrint" c_CasADi__Matrix_CasADi__SXElement___getMaxNumCallsInPrint :: IO CLong casADi__Matrix_CasADi__SXElement___getMaxNumCallsInPrint :: IO Int casADi__Matrix_CasADi__SXElement___getMaxNumCallsInPrint = c_CasADi__Matrix_CasADi__SXElement___getMaxNumCallsInPrint >>= wrapReturn -- classy wrapper sx_getMaxNumCallsInPrint :: IO Int sx_getMaxNumCallsInPrint = casADi__Matrix_CasADi__SXElement___getMaxNumCallsInPrint -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___setEqualityCheckingDepth" c_CasADi__Matrix_CasADi__SXElement___setEqualityCheckingDepth :: CInt -> IO () casADi__Matrix_CasADi__SXElement___setEqualityCheckingDepth :: Int -> IO () casADi__Matrix_CasADi__SXElement___setEqualityCheckingDepth x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_CasADi__SXElement___setEqualityCheckingDepth x0' >>= wrapReturn -- classy wrapper sx_setEqualityCheckingDepth :: Int -> IO () sx_setEqualityCheckingDepth = casADi__Matrix_CasADi__SXElement___setEqualityCheckingDepth -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___setEqualityCheckingDepth_TIC" c_CasADi__Matrix_CasADi__SXElement___setEqualityCheckingDepth_TIC :: IO () casADi__Matrix_CasADi__SXElement___setEqualityCheckingDepth' :: IO () casADi__Matrix_CasADi__SXElement___setEqualityCheckingDepth' = c_CasADi__Matrix_CasADi__SXElement___setEqualityCheckingDepth_TIC >>= wrapReturn -- classy wrapper sx_setEqualityCheckingDepth' :: IO () sx_setEqualityCheckingDepth' = casADi__Matrix_CasADi__SXElement___setEqualityCheckingDepth' -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___getEqualityCheckingDepth" c_CasADi__Matrix_CasADi__SXElement___getEqualityCheckingDepth :: IO CInt casADi__Matrix_CasADi__SXElement___getEqualityCheckingDepth :: IO Int casADi__Matrix_CasADi__SXElement___getEqualityCheckingDepth = c_CasADi__Matrix_CasADi__SXElement___getEqualityCheckingDepth >>= wrapReturn -- classy wrapper sx_getEqualityCheckingDepth :: IO Int sx_getEqualityCheckingDepth = casADi__Matrix_CasADi__SXElement___getEqualityCheckingDepth -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___className" c_CasADi__Matrix_CasADi__SXElement___className :: IO (Ptr StdString') casADi__Matrix_CasADi__SXElement___className :: IO String casADi__Matrix_CasADi__SXElement___className = c_CasADi__Matrix_CasADi__SXElement___className >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Printing. -} sx_className :: IO String sx_className = casADi__Matrix_CasADi__SXElement___className -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___printScalar_TIC" c_CasADi__Matrix_CasADi__SXElement___printScalar_TIC :: Ptr SX' -> IO () casADi__Matrix_CasADi__SXElement___printScalar' :: SX -> IO () casADi__Matrix_CasADi__SXElement___printScalar' x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_CasADi__SXElement___printScalar_TIC x0' >>= wrapReturn -- classy wrapper sx_printScalar' :: SXClass a => a -> IO () sx_printScalar' x = casADi__Matrix_CasADi__SXElement___printScalar' (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___printVector_TIC" c_CasADi__Matrix_CasADi__SXElement___printVector_TIC :: Ptr SX' -> IO () casADi__Matrix_CasADi__SXElement___printVector' :: SX -> IO () casADi__Matrix_CasADi__SXElement___printVector' x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_CasADi__SXElement___printVector_TIC x0' >>= wrapReturn -- classy wrapper sx_printVector' :: SXClass a => a -> IO () sx_printVector' x = casADi__Matrix_CasADi__SXElement___printVector' (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___printDense_TIC" c_CasADi__Matrix_CasADi__SXElement___printDense_TIC :: Ptr SX' -> IO () casADi__Matrix_CasADi__SXElement___printDense' :: SX -> IO () casADi__Matrix_CasADi__SXElement___printDense' x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_CasADi__SXElement___printDense_TIC x0' >>= wrapReturn -- classy wrapper sx_printDense' :: SXClass a => a -> IO () sx_printDense' x = casADi__Matrix_CasADi__SXElement___printDense' (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___printSparse_TIC" c_CasADi__Matrix_CasADi__SXElement___printSparse_TIC :: Ptr SX' -> IO () casADi__Matrix_CasADi__SXElement___printSparse' :: SX -> IO () casADi__Matrix_CasADi__SXElement___printSparse' x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_CasADi__SXElement___printSparse_TIC x0' >>= wrapReturn -- classy wrapper sx_printSparse' :: SXClass a => a -> IO () sx_printSparse' x = casADi__Matrix_CasADi__SXElement___printSparse' (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___row" c_CasADi__Matrix_CasADi__SXElement___row :: Ptr SX' -> CInt -> IO CInt casADi__Matrix_CasADi__SXElement___row :: SX -> Int -> IO Int casADi__Matrix_CasADi__SXElement___row x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_CasADi__SXElement___row x0' x1' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] -} sx_row :: SXClass a => a -> Int -> IO Int sx_row x = casADi__Matrix_CasADi__SXElement___row (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___colind" c_CasADi__Matrix_CasADi__SXElement___colind :: Ptr SX' -> CInt -> IO CInt casADi__Matrix_CasADi__SXElement___colind :: SX -> Int -> IO Int casADi__Matrix_CasADi__SXElement___colind x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_CasADi__SXElement___colind x0' x1' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] -} sx_colind :: SXClass a => a -> Int -> IO Int sx_colind x = casADi__Matrix_CasADi__SXElement___colind (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___clear" c_CasADi__Matrix_CasADi__SXElement___clear :: Ptr SX' -> IO () casADi__Matrix_CasADi__SXElement___clear :: SX -> IO () casADi__Matrix_CasADi__SXElement___clear x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_CasADi__SXElement___clear x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] -} sx_clear :: SXClass a => a -> IO () sx_clear x = casADi__Matrix_CasADi__SXElement___clear (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___resize" c_CasADi__Matrix_CasADi__SXElement___resize :: Ptr SX' -> CInt -> CInt -> IO () casADi__Matrix_CasADi__SXElement___resize :: SX -> Int -> Int -> IO () casADi__Matrix_CasADi__SXElement___resize x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_CasADi__SXElement___resize x0' x1' x2' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] -} sx_resize :: SXClass a => a -> Int -> Int -> IO () sx_resize x = casADi__Matrix_CasADi__SXElement___resize (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___reserve" c_CasADi__Matrix_CasADi__SXElement___reserve :: Ptr SX' -> CInt -> IO () casADi__Matrix_CasADi__SXElement___reserve :: SX -> Int -> IO () casADi__Matrix_CasADi__SXElement___reserve x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_CasADi__SXElement___reserve x0' x1' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] -} sx_reserve :: SXClass a => a -> Int -> IO () sx_reserve x = casADi__Matrix_CasADi__SXElement___reserve (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___reserve_TIC" c_CasADi__Matrix_CasADi__SXElement___reserve_TIC :: Ptr SX' -> CInt -> CInt -> IO () casADi__Matrix_CasADi__SXElement___reserve' :: SX -> Int -> Int -> IO () casADi__Matrix_CasADi__SXElement___reserve' x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_CasADi__SXElement___reserve_TIC x0' x1' x2' >>= wrapReturn -- classy wrapper sx_reserve' :: SXClass a => a -> Int -> Int -> IO () sx_reserve' x = casADi__Matrix_CasADi__SXElement___reserve' (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___erase" c_CasADi__Matrix_CasADi__SXElement___erase :: Ptr SX' -> Ptr (CppVec CInt) -> Ptr (CppVec CInt) -> IO () casADi__Matrix_CasADi__SXElement___erase :: SX -> Vector Int -> Vector Int -> IO () casADi__Matrix_CasADi__SXElement___erase x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_CasADi__SXElement___erase x0' x1' x2' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Erase a submatrix >Erase rows and/or columns of a matrix. -} sx_erase :: SXClass a => a -> Vector Int -> Vector Int -> IO () sx_erase x = casADi__Matrix_CasADi__SXElement___erase (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___remove" c_CasADi__Matrix_CasADi__SXElement___remove :: Ptr SX' -> Ptr (CppVec CInt) -> Ptr (CppVec CInt) -> IO () casADi__Matrix_CasADi__SXElement___remove :: SX -> Vector Int -> Vector Int -> IO () casADi__Matrix_CasADi__SXElement___remove x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_CasADi__SXElement___remove x0' x1' x2' >>= wrapReturn -- classy wrapper {-| > [INTERNAL] Remove cols or >rows Rremove/delete rows and/or columns of a matrix. -} sx_remove :: SXClass a => a -> Vector Int -> Vector Int -> IO () sx_remove x = casADi__Matrix_CasADi__SXElement___remove (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___enlarge" c_CasADi__Matrix_CasADi__SXElement___enlarge :: Ptr SX' -> CInt -> CInt -> Ptr (CppVec CInt) -> Ptr (CppVec CInt) -> IO () casADi__Matrix_CasADi__SXElement___enlarge :: SX -> Int -> Int -> Vector Int -> Vector Int -> IO () casADi__Matrix_CasADi__SXElement___enlarge x0 x1 x2 x3 x4 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> withMarshal x4 $ \x4' -> c_CasADi__Matrix_CasADi__SXElement___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. -} sx_enlarge :: SXClass a => a -> Int -> Int -> Vector Int -> Vector Int -> IO () sx_enlarge x = casADi__Matrix_CasADi__SXElement___enlarge (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___data" c_CasADi__Matrix_CasADi__SXElement___data :: Ptr SX' -> IO (Ptr (CppVec (Ptr SXElement'))) casADi__Matrix_CasADi__SXElement___data :: SX -> IO (Vector SXElement) casADi__Matrix_CasADi__SXElement___data x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_CasADi__SXElement___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. -} sx_data :: SXClass a => a -> IO (Vector SXElement) sx_data x = casADi__Matrix_CasADi__SXElement___data (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___sparsityRef" c_CasADi__Matrix_CasADi__SXElement___sparsityRef :: Ptr SX' -> IO (Ptr Sparsity') casADi__Matrix_CasADi__SXElement___sparsityRef :: SX -> IO Sparsity casADi__Matrix_CasADi__SXElement___sparsityRef x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_CasADi__SXElement___sparsityRef x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Access the >sparsity, make a copy if there are multiple references to it. -} sx_sparsityRef :: SXClass a => a -> IO Sparsity sx_sparsityRef x = casADi__Matrix_CasADi__SXElement___sparsityRef (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___set" c_CasADi__Matrix_CasADi__SXElement___set :: Ptr SX' -> Ptr SXElement' -> CInt -> IO () casADi__Matrix_CasADi__SXElement___set :: SX -> SXElement -> SparsityType -> IO () casADi__Matrix_CasADi__SXElement___set x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_CasADi__SXElement___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. -} sx_set :: SXClass a => a -> SXElement -> SparsityType -> IO () sx_set x = casADi__Matrix_CasADi__SXElement___set (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___set_TIC" c_CasADi__Matrix_CasADi__SXElement___set_TIC :: Ptr SX' -> Ptr SXElement' -> IO () casADi__Matrix_CasADi__SXElement___set' :: SX -> SXElement -> IO () casADi__Matrix_CasADi__SXElement___set' x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_CasADi__SXElement___set_TIC x0' x1' >>= wrapReturn -- classy wrapper sx_set' :: SXClass a => a -> SXElement -> IO () sx_set' x = casADi__Matrix_CasADi__SXElement___set' (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___get" c_CasADi__Matrix_CasADi__SXElement___get :: Ptr SX' -> Ptr SXElement' -> CInt -> IO () casADi__Matrix_CasADi__SXElement___get :: SX -> SXElement -> SparsityType -> IO () casADi__Matrix_CasADi__SXElement___get x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_CasADi__SXElement___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. -} sx_get :: SXClass a => a -> SXElement -> SparsityType -> IO () sx_get x = casADi__Matrix_CasADi__SXElement___get (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___get_TIC" c_CasADi__Matrix_CasADi__SXElement___get_TIC :: Ptr SX' -> Ptr SXElement' -> IO () casADi__Matrix_CasADi__SXElement___get' :: SX -> SXElement -> IO () casADi__Matrix_CasADi__SXElement___get' x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_CasADi__SXElement___get_TIC x0' x1' >>= wrapReturn -- classy wrapper sx_get' :: SXClass a => a -> SXElement -> IO () sx_get' x = casADi__Matrix_CasADi__SXElement___get' (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___set_TIC_TIC" c_CasADi__Matrix_CasADi__SXElement___set_TIC_TIC :: Ptr SX' -> Ptr (CppVec (Ptr SXElement')) -> CInt -> IO () casADi__Matrix_CasADi__SXElement___set'' :: SX -> Vector SXElement -> SparsityType -> IO () casADi__Matrix_CasADi__SXElement___set'' x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_CasADi__SXElement___set_TIC_TIC x0' x1' x2' >>= wrapReturn -- classy wrapper sx_set'' :: SXClass a => a -> Vector SXElement -> SparsityType -> IO () sx_set'' x = casADi__Matrix_CasADi__SXElement___set'' (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___set_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SXElement___set_TIC_TIC_TIC :: Ptr SX' -> Ptr (CppVec (Ptr SXElement')) -> IO () casADi__Matrix_CasADi__SXElement___set''' :: SX -> Vector SXElement -> IO () casADi__Matrix_CasADi__SXElement___set''' x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_CasADi__SXElement___set_TIC_TIC_TIC x0' x1' >>= wrapReturn -- classy wrapper sx_set''' :: SXClass a => a -> Vector SXElement -> IO () sx_set''' x = casADi__Matrix_CasADi__SXElement___set''' (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___get_TIC_TIC" c_CasADi__Matrix_CasADi__SXElement___get_TIC_TIC :: Ptr SX' -> Ptr (CppVec (Ptr SXElement')) -> CInt -> IO () casADi__Matrix_CasADi__SXElement___get'' :: SX -> Vector SXElement -> SparsityType -> IO () casADi__Matrix_CasADi__SXElement___get'' x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_CasADi__SXElement___get_TIC_TIC x0' x1' x2' >>= wrapReturn -- classy wrapper sx_get'' :: SXClass a => a -> Vector SXElement -> SparsityType -> IO () sx_get'' x = casADi__Matrix_CasADi__SXElement___get'' (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___get_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SXElement___get_TIC_TIC_TIC :: Ptr SX' -> Ptr (CppVec (Ptr SXElement')) -> IO () casADi__Matrix_CasADi__SXElement___get''' :: SX -> Vector SXElement -> IO () casADi__Matrix_CasADi__SXElement___get''' x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_CasADi__SXElement___get_TIC_TIC_TIC x0' x1' >>= wrapReturn -- classy wrapper sx_get''' :: SXClass a => a -> Vector SXElement -> IO () sx_get''' x = casADi__Matrix_CasADi__SXElement___get''' (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___set_TIC_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SXElement___set_TIC_TIC_TIC_TIC :: Ptr SX' -> Ptr SX' -> CInt -> IO () casADi__Matrix_CasADi__SXElement___set'''' :: SX -> SX -> SparsityType -> IO () casADi__Matrix_CasADi__SXElement___set'''' x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_CasADi__SXElement___set_TIC_TIC_TIC_TIC x0' x1' x2' >>= wrapReturn -- classy wrapper sx_set'''' :: SXClass a => a -> SX -> SparsityType -> IO () sx_set'''' x = casADi__Matrix_CasADi__SXElement___set'''' (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___set_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SXElement___set_TIC_TIC_TIC_TIC_TIC :: Ptr SX' -> Ptr SX' -> IO () casADi__Matrix_CasADi__SXElement___set''''' :: SX -> SX -> IO () casADi__Matrix_CasADi__SXElement___set''''' x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_CasADi__SXElement___set_TIC_TIC_TIC_TIC_TIC x0' x1' >>= wrapReturn -- classy wrapper sx_set''''' :: SXClass a => a -> SX -> IO () sx_set''''' x = casADi__Matrix_CasADi__SXElement___set''''' (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___get_TIC_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SXElement___get_TIC_TIC_TIC_TIC :: Ptr SX' -> Ptr SX' -> CInt -> IO () casADi__Matrix_CasADi__SXElement___get'''' :: SX -> SX -> SparsityType -> IO () casADi__Matrix_CasADi__SXElement___get'''' x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_CasADi__SXElement___get_TIC_TIC_TIC_TIC x0' x1' x2' >>= wrapReturn -- classy wrapper sx_get'''' :: SXClass a => a -> SX -> SparsityType -> IO () sx_get'''' x = casADi__Matrix_CasADi__SXElement___get'''' (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___get_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SXElement___get_TIC_TIC_TIC_TIC_TIC :: Ptr SX' -> Ptr SX' -> IO () casADi__Matrix_CasADi__SXElement___get''''' :: SX -> SX -> IO () casADi__Matrix_CasADi__SXElement___get''''' x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_CasADi__SXElement___get_TIC_TIC_TIC_TIC_TIC x0' x1' >>= wrapReturn -- classy wrapper sx_get''''' :: SXClass a => a -> SX -> IO () sx_get''''' x = casADi__Matrix_CasADi__SXElement___get''''' (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___triplet" c_CasADi__Matrix_CasADi__SXElement___triplet :: Ptr (CppVec CInt) -> Ptr (CppVec CInt) -> Ptr (CppVec (Ptr SXElement')) -> IO (Ptr SX') casADi__Matrix_CasADi__SXElement___triplet :: Vector Int -> Vector Int -> Vector SXElement -> IO SX casADi__Matrix_CasADi__SXElement___triplet x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_CasADi__SXElement___triplet x0' x1' x2' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] -} sx_triplet :: Vector Int -> Vector Int -> Vector SXElement -> IO SX sx_triplet = casADi__Matrix_CasADi__SXElement___triplet -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___triplet_TIC" c_CasADi__Matrix_CasADi__SXElement___triplet_TIC :: Ptr (CppVec CInt) -> Ptr (CppVec CInt) -> Ptr (CppVec (Ptr SXElement')) -> CInt -> CInt -> IO (Ptr SX') casADi__Matrix_CasADi__SXElement___triplet' :: Vector Int -> Vector Int -> Vector SXElement -> Int -> Int -> IO SX casADi__Matrix_CasADi__SXElement___triplet' x0 x1 x2 x3 x4 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> withMarshal x3 $ \x3' -> withMarshal x4 $ \x4' -> c_CasADi__Matrix_CasADi__SXElement___triplet_TIC x0' x1' x2' x3' x4' >>= wrapReturn -- classy wrapper sx_triplet' :: Vector Int -> Vector Int -> Vector SXElement -> Int -> Int -> IO SX sx_triplet' = casADi__Matrix_CasADi__SXElement___triplet' -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___inf" c_CasADi__Matrix_CasADi__SXElement___inf :: Ptr Sparsity' -> IO (Ptr SX') casADi__Matrix_CasADi__SXElement___inf :: Sparsity -> IO SX casADi__Matrix_CasADi__SXElement___inf x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_CasADi__SXElement___inf x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] create a matrix with >all inf -} sx_inf :: Sparsity -> IO SX sx_inf = casADi__Matrix_CasADi__SXElement___inf -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___inf_TIC" c_CasADi__Matrix_CasADi__SXElement___inf_TIC :: CInt -> CInt -> IO (Ptr SX') casADi__Matrix_CasADi__SXElement___inf' :: Int -> Int -> IO SX casADi__Matrix_CasADi__SXElement___inf' x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_CasADi__SXElement___inf_TIC x0' x1' >>= wrapReturn -- classy wrapper sx_inf' :: Int -> Int -> IO SX sx_inf' = casADi__Matrix_CasADi__SXElement___inf' -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___inf_TIC_TIC" c_CasADi__Matrix_CasADi__SXElement___inf_TIC_TIC :: CInt -> IO (Ptr SX') casADi__Matrix_CasADi__SXElement___inf'' :: Int -> IO SX casADi__Matrix_CasADi__SXElement___inf'' x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_CasADi__SXElement___inf_TIC_TIC x0' >>= wrapReturn -- classy wrapper sx_inf'' :: Int -> IO SX sx_inf'' = casADi__Matrix_CasADi__SXElement___inf'' -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___inf_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SXElement___inf_TIC_TIC_TIC :: IO (Ptr SX') casADi__Matrix_CasADi__SXElement___inf''' :: IO SX casADi__Matrix_CasADi__SXElement___inf''' = c_CasADi__Matrix_CasADi__SXElement___inf_TIC_TIC_TIC >>= wrapReturn -- classy wrapper sx_inf''' :: IO SX sx_inf''' = casADi__Matrix_CasADi__SXElement___inf''' -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___nan" c_CasADi__Matrix_CasADi__SXElement___nan :: Ptr Sparsity' -> IO (Ptr SX') casADi__Matrix_CasADi__SXElement___nan :: Sparsity -> IO SX casADi__Matrix_CasADi__SXElement___nan x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_CasADi__SXElement___nan x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] create a matrix with >all nan -} sx_nan :: Sparsity -> IO SX sx_nan = casADi__Matrix_CasADi__SXElement___nan -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___nan_TIC" c_CasADi__Matrix_CasADi__SXElement___nan_TIC :: CInt -> CInt -> IO (Ptr SX') casADi__Matrix_CasADi__SXElement___nan' :: Int -> Int -> IO SX casADi__Matrix_CasADi__SXElement___nan' x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_CasADi__SXElement___nan_TIC x0' x1' >>= wrapReturn -- classy wrapper sx_nan' :: Int -> Int -> IO SX sx_nan' = casADi__Matrix_CasADi__SXElement___nan' -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___nan_TIC_TIC" c_CasADi__Matrix_CasADi__SXElement___nan_TIC_TIC :: CInt -> IO (Ptr SX') casADi__Matrix_CasADi__SXElement___nan'' :: Int -> IO SX casADi__Matrix_CasADi__SXElement___nan'' x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_CasADi__SXElement___nan_TIC_TIC x0' >>= wrapReturn -- classy wrapper sx_nan'' :: Int -> IO SX sx_nan'' = casADi__Matrix_CasADi__SXElement___nan'' -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___nan_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SXElement___nan_TIC_TIC_TIC :: IO (Ptr SX') casADi__Matrix_CasADi__SXElement___nan''' :: IO SX casADi__Matrix_CasADi__SXElement___nan''' = c_CasADi__Matrix_CasADi__SXElement___nan_TIC_TIC_TIC >>= wrapReturn -- classy wrapper sx_nan''' :: IO SX sx_nan''' = casADi__Matrix_CasADi__SXElement___nan''' -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___repmat" c_CasADi__Matrix_CasADi__SXElement___repmat :: Ptr SXElement' -> Ptr Sparsity' -> IO (Ptr SX') casADi__Matrix_CasADi__SXElement___repmat :: SXElement -> Sparsity -> IO SX casADi__Matrix_CasADi__SXElement___repmat x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_CasADi__SXElement___repmat x0' x1' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] create a matrix >by repeating an existing matrix -} sx_repmat :: SXElement -> Sparsity -> IO SX sx_repmat = casADi__Matrix_CasADi__SXElement___repmat -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___repmat_TIC" c_CasADi__Matrix_CasADi__SXElement___repmat_TIC :: Ptr SX' -> Ptr Sparsity' -> IO (Ptr SX') casADi__Matrix_CasADi__SXElement___repmat' :: SX -> Sparsity -> IO SX casADi__Matrix_CasADi__SXElement___repmat' x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_CasADi__SXElement___repmat_TIC x0' x1' >>= wrapReturn -- classy wrapper sx_repmat' :: SX -> Sparsity -> IO SX sx_repmat' = casADi__Matrix_CasADi__SXElement___repmat' -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___repmat_TIC_TIC" c_CasADi__Matrix_CasADi__SXElement___repmat_TIC_TIC :: Ptr SX' -> CInt -> CInt -> IO (Ptr SX') casADi__Matrix_CasADi__SXElement___repmat'' :: SX -> Int -> Int -> IO SX casADi__Matrix_CasADi__SXElement___repmat'' x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_CasADi__SXElement___repmat_TIC_TIC x0' x1' x2' >>= wrapReturn -- classy wrapper sx_repmat'' :: SX -> Int -> Int -> IO SX sx_repmat'' = casADi__Matrix_CasADi__SXElement___repmat'' -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___repmat_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SXElement___repmat_TIC_TIC_TIC :: Ptr SX' -> CInt -> IO (Ptr SX') casADi__Matrix_CasADi__SXElement___repmat''' :: SX -> Int -> IO SX casADi__Matrix_CasADi__SXElement___repmat''' x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_CasADi__SXElement___repmat_TIC_TIC_TIC x0' x1' >>= wrapReturn -- classy wrapper sx_repmat''' :: SX -> Int -> IO SX sx_repmat''' = casADi__Matrix_CasADi__SXElement___repmat''' -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___eye" c_CasADi__Matrix_CasADi__SXElement___eye :: CInt -> IO (Ptr SX') casADi__Matrix_CasADi__SXElement___eye :: Int -> IO SX casADi__Matrix_CasADi__SXElement___eye x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_CasADi__SXElement___eye x0' >>= wrapReturn -- classy wrapper sx_eye :: Int -> IO SX sx_eye = casADi__Matrix_CasADi__SXElement___eye -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___isRegular" c_CasADi__Matrix_CasADi__SXElement___isRegular :: Ptr SX' -> IO CInt casADi__Matrix_CasADi__SXElement___isRegular :: SX -> IO Bool casADi__Matrix_CasADi__SXElement___isRegular x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_CasADi__SXElement___isRegular x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Checks if >expression does not contain NaN or Inf. -} sx_isRegular :: SXClass a => a -> IO Bool sx_isRegular x = casADi__Matrix_CasADi__SXElement___isRegular (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___isSmooth" c_CasADi__Matrix_CasADi__SXElement___isSmooth :: Ptr SX' -> IO CInt casADi__Matrix_CasADi__SXElement___isSmooth :: SX -> IO Bool casADi__Matrix_CasADi__SXElement___isSmooth x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_CasADi__SXElement___isSmooth x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Check if >smooth. -} sx_isSmooth :: SXClass a => a -> IO Bool sx_isSmooth x = casADi__Matrix_CasADi__SXElement___isSmooth (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___isSymbolic" c_CasADi__Matrix_CasADi__SXElement___isSymbolic :: Ptr SX' -> IO CInt casADi__Matrix_CasADi__SXElement___isSymbolic :: SX -> IO Bool casADi__Matrix_CasADi__SXElement___isSymbolic x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_CasADi__SXElement___isSymbolic x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Check if >symbolic (Dense) Sparse matrices invariable return false. -} sx_isSymbolic :: SXClass a => a -> IO Bool sx_isSymbolic x = casADi__Matrix_CasADi__SXElement___isSymbolic (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___isSymbolicSparse" c_CasADi__Matrix_CasADi__SXElement___isSymbolicSparse :: Ptr SX' -> IO CInt casADi__Matrix_CasADi__SXElement___isSymbolicSparse :: SX -> IO Bool casADi__Matrix_CasADi__SXElement___isSymbolicSparse x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_CasADi__SXElement___isSymbolicSparse x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Check >if symbolic Sparse matrices can return true if all non-zero elements are >symbolic. -} sx_isSymbolicSparse :: SXClass a => a -> IO Bool sx_isSymbolicSparse x = casADi__Matrix_CasADi__SXElement___isSymbolicSparse (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___isConstant" c_CasADi__Matrix_CasADi__SXElement___isConstant :: Ptr SX' -> IO CInt casADi__Matrix_CasADi__SXElement___isConstant :: SX -> IO Bool casADi__Matrix_CasADi__SXElement___isConstant x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_CasADi__SXElement___isConstant x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Check if the >matrix is constant (note that false negative answers are possible) -} sx_isConstant :: SXClass a => a -> IO Bool sx_isConstant x = casADi__Matrix_CasADi__SXElement___isConstant (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___isInteger" c_CasADi__Matrix_CasADi__SXElement___isInteger :: Ptr SX' -> IO CInt casADi__Matrix_CasADi__SXElement___isInteger :: SX -> IO Bool casADi__Matrix_CasADi__SXElement___isInteger x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_CasADi__SXElement___isInteger x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Check if the >matrix is integer-valued (note that false negative answers are possible) -} sx_isInteger :: SXClass a => a -> IO Bool sx_isInteger x = casADi__Matrix_CasADi__SXElement___isInteger (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___isZero" c_CasADi__Matrix_CasADi__SXElement___isZero :: Ptr SX' -> IO CInt casADi__Matrix_CasADi__SXElement___isZero :: SX -> IO Bool casADi__Matrix_CasADi__SXElement___isZero x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_CasADi__SXElement___isZero x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] check if the >matrix is 0 (note that false negative answers are possible) -} sx_isZero :: SXClass a => a -> IO Bool sx_isZero x = casADi__Matrix_CasADi__SXElement___isZero (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___isOne" c_CasADi__Matrix_CasADi__SXElement___isOne :: Ptr SX' -> IO CInt casADi__Matrix_CasADi__SXElement___isOne :: SX -> IO Bool casADi__Matrix_CasADi__SXElement___isOne x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_CasADi__SXElement___isOne x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] check if the >matrix is 1 (note that false negative answers are possible) -} sx_isOne :: SXClass a => a -> IO Bool sx_isOne x = casADi__Matrix_CasADi__SXElement___isOne (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___isMinusOne" c_CasADi__Matrix_CasADi__SXElement___isMinusOne :: Ptr SX' -> IO CInt casADi__Matrix_CasADi__SXElement___isMinusOne :: SX -> IO Bool casADi__Matrix_CasADi__SXElement___isMinusOne x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_CasADi__SXElement___isMinusOne x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] check if the >matrix is -1 (note that false negative answers are possible) -} sx_isMinusOne :: SXClass a => a -> IO Bool sx_isMinusOne x = casADi__Matrix_CasADi__SXElement___isMinusOne (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___isIdentity" c_CasADi__Matrix_CasADi__SXElement___isIdentity :: Ptr SX' -> IO CInt casADi__Matrix_CasADi__SXElement___isIdentity :: SX -> IO Bool casADi__Matrix_CasADi__SXElement___isIdentity x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_CasADi__SXElement___isIdentity x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] check if the >matrix is an identity matrix (note that false negative answers are possible) -} sx_isIdentity :: SXClass a => a -> IO Bool sx_isIdentity x = casADi__Matrix_CasADi__SXElement___isIdentity (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___isEqual" c_CasADi__Matrix_CasADi__SXElement___isEqual :: Ptr SX' -> Ptr SX' -> IO CInt casADi__Matrix_CasADi__SXElement___isEqual :: SX -> SX -> IO Bool casADi__Matrix_CasADi__SXElement___isEqual x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_CasADi__SXElement___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 -} sx_isEqual :: SXClass a => a -> SX -> IO Bool sx_isEqual x = casADi__Matrix_CasADi__SXElement___isEqual (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___hasNonStructuralZeros" c_CasADi__Matrix_CasADi__SXElement___hasNonStructuralZeros :: Ptr SX' -> IO CInt casADi__Matrix_CasADi__SXElement___hasNonStructuralZeros :: SX -> IO Bool casADi__Matrix_CasADi__SXElement___hasNonStructuralZeros x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_CasADi__SXElement___hasNonStructuralZeros x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] >Check if the matrix has any zero entries which are not structural zeros. -} sx_hasNonStructuralZeros :: SXClass a => a -> IO Bool sx_hasNonStructuralZeros x = casADi__Matrix_CasADi__SXElement___hasNonStructuralZeros (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___getValue" c_CasADi__Matrix_CasADi__SXElement___getValue :: Ptr SX' -> IO CDouble casADi__Matrix_CasADi__SXElement___getValue :: SX -> IO Double casADi__Matrix_CasADi__SXElement___getValue x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_CasADi__SXElement___getValue x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Get double >value (only if constant) -} sx_getValue :: SXClass a => a -> IO Double sx_getValue x = casADi__Matrix_CasADi__SXElement___getValue (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___getName" c_CasADi__Matrix_CasADi__SXElement___getName :: Ptr SX' -> IO (Ptr StdString') casADi__Matrix_CasADi__SXElement___getName :: SX -> IO String casADi__Matrix_CasADi__SXElement___getName x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_CasADi__SXElement___getName x0' >>= wrapReturn -- classy wrapper {-| >[INTERNAL] Get name (only >if symbolic scalar) -} sx_getName :: SXClass a => a -> IO String sx_getName x = casADi__Matrix_CasADi__SXElement___getName (castSX x) -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___setPrecision" c_CasADi__Matrix_CasADi__SXElement___setPrecision :: CInt -> IO () casADi__Matrix_CasADi__SXElement___setPrecision :: Int -> IO () casADi__Matrix_CasADi__SXElement___setPrecision x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_CasADi__SXElement___setPrecision x0' >>= wrapReturn -- classy wrapper {-| >Set the 'precision, width & scientific' used in printing and serializing to >streams. -} sx_setPrecision :: Int -> IO () sx_setPrecision = casADi__Matrix_CasADi__SXElement___setPrecision -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___setWidth" c_CasADi__Matrix_CasADi__SXElement___setWidth :: CInt -> IO () casADi__Matrix_CasADi__SXElement___setWidth :: Int -> IO () casADi__Matrix_CasADi__SXElement___setWidth x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_CasADi__SXElement___setWidth x0' >>= wrapReturn -- classy wrapper {-| >Set the 'precision, width & scientific' used in printing and serializing to >streams. -} sx_setWidth :: Int -> IO () sx_setWidth = casADi__Matrix_CasADi__SXElement___setWidth -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___setScientific" c_CasADi__Matrix_CasADi__SXElement___setScientific :: CInt -> IO () casADi__Matrix_CasADi__SXElement___setScientific :: Bool -> IO () casADi__Matrix_CasADi__SXElement___setScientific x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_CasADi__SXElement___setScientific x0' >>= wrapReturn -- classy wrapper {-| >Set the 'precision, width & scientific' used in printing and serializing to >streams. -} sx_setScientific :: Bool -> IO () sx_setScientific = casADi__Matrix_CasADi__SXElement___setScientific -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___SX" c_CasADi__Matrix_CasADi__SXElement___SX :: IO (Ptr SX') casADi__Matrix_CasADi__SXElement___SX :: IO SX casADi__Matrix_CasADi__SXElement___SX = c_CasADi__Matrix_CasADi__SXElement___SX >>= 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. -} sx :: IO SX sx = casADi__Matrix_CasADi__SXElement___SX -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___SX_TIC" c_CasADi__Matrix_CasADi__SXElement___SX_TIC :: Ptr SX' -> IO (Ptr SX') casADi__Matrix_CasADi__SXElement___SX' :: SX -> IO SX casADi__Matrix_CasADi__SXElement___SX' x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_CasADi__SXElement___SX_TIC x0' >>= wrapReturn -- classy wrapper sx' :: SX -> IO SX sx' = casADi__Matrix_CasADi__SXElement___SX' -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC" c_CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC :: Ptr (CppVec (Ptr (CppVec (Ptr SXElement')))) -> IO (Ptr SX') casADi__Matrix_CasADi__SXElement___SX'' :: Vector (Vector SXElement) -> IO SX casADi__Matrix_CasADi__SXElement___SX'' x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC x0' >>= wrapReturn -- classy wrapper sx'' :: Vector (Vector SXElement) -> IO SX sx'' = casADi__Matrix_CasADi__SXElement___SX'' -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC :: Ptr Sparsity' -> Ptr SXElement' -> IO (Ptr SX') casADi__Matrix_CasADi__SXElement___SX''' :: Sparsity -> SXElement -> IO SX casADi__Matrix_CasADi__SXElement___SX''' x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC x0' x1' >>= wrapReturn -- classy wrapper sx''' :: Sparsity -> SXElement -> IO SX sx''' = casADi__Matrix_CasADi__SXElement___SX''' -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC :: Ptr Sparsity' -> IO (Ptr SX') casADi__Matrix_CasADi__SXElement___SX'''' :: Sparsity -> IO SX casADi__Matrix_CasADi__SXElement___SX'''' x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC x0' >>= wrapReturn -- classy wrapper sx'''' :: Sparsity -> IO SX sx'''' = casADi__Matrix_CasADi__SXElement___SX'''' -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC_TIC :: Ptr Sparsity' -> Ptr (CppVec (Ptr SXElement')) -> IO (Ptr SX') casADi__Matrix_CasADi__SXElement___SX''''' :: Sparsity -> Vector SXElement -> IO SX casADi__Matrix_CasADi__SXElement___SX''''' x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> c_CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC_TIC x0' x1' >>= wrapReturn -- classy wrapper sx''''' :: Sparsity -> Vector SXElement -> IO SX sx''''' = casADi__Matrix_CasADi__SXElement___SX''''' -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC_TIC_TIC :: CDouble -> IO (Ptr SX') casADi__Matrix_CasADi__SXElement___SX'''''' :: Double -> IO SX casADi__Matrix_CasADi__SXElement___SX'''''' x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC_TIC_TIC x0' >>= wrapReturn -- classy wrapper sx'''''' :: Double -> IO SX sx'''''' = casADi__Matrix_CasADi__SXElement___SX'''''' -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC_TIC_TIC_TIC :: Ptr (CppVec (Ptr SXElement')) -> IO (Ptr SX') casADi__Matrix_CasADi__SXElement___SX''''''' :: Vector SXElement -> IO SX casADi__Matrix_CasADi__SXElement___SX''''''' x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' >>= wrapReturn -- classy wrapper sx''''''' :: Vector SXElement -> IO SX sx''''''' = casADi__Matrix_CasADi__SXElement___SX''''''' -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC :: Ptr (CppVec (Ptr SXElement')) -> CInt -> CInt -> IO (Ptr SX') casADi__Matrix_CasADi__SXElement___SX'''''''' :: Vector SXElement -> Int -> Int -> IO SX casADi__Matrix_CasADi__SXElement___SX'''''''' x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' >>= wrapReturn -- classy wrapper sx'''''''' :: Vector SXElement -> Int -> Int -> IO SX sx'''''''' = casADi__Matrix_CasADi__SXElement___SX'''''''' -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC :: Ptr IMatrix' -> IO (Ptr SX') casADi__Matrix_CasADi__SXElement___SX''''''''' :: IMatrix -> IO SX casADi__Matrix_CasADi__SXElement___SX''''''''' x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' >>= wrapReturn -- classy wrapper sx''''''''' :: IMatrix -> IO SX sx''''''''' = casADi__Matrix_CasADi__SXElement___SX''''''''' -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC :: Ptr (CppVec CInt) -> IO (Ptr SX') casADi__Matrix_CasADi__SXElement___SX'''''''''' :: Vector Int -> IO SX casADi__Matrix_CasADi__SXElement___SX'''''''''' x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' >>= wrapReturn -- classy wrapper sx'''''''''' :: Vector Int -> IO SX sx'''''''''' = casADi__Matrix_CasADi__SXElement___SX'''''''''' -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC :: Ptr (CppVec CInt) -> CInt -> CInt -> IO (Ptr SX') casADi__Matrix_CasADi__SXElement___SX''''''''''' :: Vector Int -> Int -> Int -> IO SX casADi__Matrix_CasADi__SXElement___SX''''''''''' x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' >>= wrapReturn -- classy wrapper sx''''''''''' :: Vector Int -> Int -> Int -> IO SX sx''''''''''' = casADi__Matrix_CasADi__SXElement___SX''''''''''' -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC :: Ptr DMatrix' -> IO (Ptr SX') casADi__Matrix_CasADi__SXElement___SX'''''''''''' :: DMatrix -> IO SX casADi__Matrix_CasADi__SXElement___SX'''''''''''' x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' >>= wrapReturn -- classy wrapper sx'''''''''''' :: DMatrix -> IO SX sx'''''''''''' = casADi__Matrix_CasADi__SXElement___SX'''''''''''' -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC :: Ptr (CppVec CDouble) -> IO (Ptr SX') casADi__Matrix_CasADi__SXElement___SX''''''''''''' :: Vector Double -> IO SX casADi__Matrix_CasADi__SXElement___SX''''''''''''' x0 = withMarshal x0 $ \x0' -> c_CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' >>= wrapReturn -- classy wrapper sx''''''''''''' :: Vector Double -> IO SX sx''''''''''''' = casADi__Matrix_CasADi__SXElement___SX''''''''''''' -- direct wrapper foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC :: Ptr (CppVec CDouble) -> CInt -> CInt -> IO (Ptr SX') casADi__Matrix_CasADi__SXElement___SX'''''''''''''' :: Vector Double -> Int -> Int -> IO SX casADi__Matrix_CasADi__SXElement___SX'''''''''''''' x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> c_CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' >>= wrapReturn -- classy wrapper sx'''''''''''''' :: Vector Double -> Int -> Int -> IO SX sx'''''''''''''' = casADi__Matrix_CasADi__SXElement___SX''''''''''''''