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