casadi-bindings-1.9.0.0: Casadi/Wrappers/Classes/IMatrix.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.IMatrix
       (
         IMatrix,
         IMatrixClass(..),
         imatrix,
         imatrix',
         imatrix'',
         imatrix''',
         imatrix'''',
         imatrix''''',
         imatrix'''''',
         imatrix''''''',
         imatrix'''''''',
         imatrix___add__,
         imatrix___constpow__,
         imatrix___copysign__,
         imatrix___div__,
         imatrix___eq__,
         imatrix___le__,
         imatrix___lt__,
         imatrix___mpower__,
         imatrix___mrdivide__,
         imatrix___mul__,
         imatrix___ne__,
         imatrix___nonzero__,
         imatrix___pow__,
         imatrix___sub__,
         imatrix___truediv__,
         imatrix_append,
         imatrix_appendColumns,
         imatrix_arccos,
         imatrix_arccosh,
         imatrix_arcsin,
         imatrix_arcsinh,
         imatrix_arctan,
         imatrix_arctan2,
         imatrix_arctanh,
         imatrix_at,
         imatrix_binary,
         imatrix_ceil,
         imatrix_className,
         imatrix_clear,
         imatrix_colind,
         imatrix_cos,
         imatrix_cosh,
         imatrix_data,
         imatrix_densify,
         imatrix_densify',
         imatrix_elem,
         imatrix_elem',
         imatrix_enlarge,
         imatrix_erase,
         imatrix_erf,
         imatrix_erfinv,
         imatrix_exp,
         imatrix_eye,
         imatrix_fabs,
         imatrix_floor,
         imatrix_fmax,
         imatrix_fmin,
         imatrix_get,
         imatrix_get',
         imatrix_get'',
         imatrix_get''',
         imatrix_get'''',
         imatrix_get''''',
         imatrix_getEqualityCheckingDepth,
         imatrix_getMaxNumCallsInPrint,
         imatrix_getName,
         imatrix_getValue,
         imatrix_hasNZ,
         imatrix_hasNonStructuralZeros,
         imatrix_if_else_zero,
         imatrix_indexed_assignment,
         imatrix_indexed_assignment',
         imatrix_indexed_assignment'',
         imatrix_indexed_assignment''',
         imatrix_indexed_assignment'''',
         imatrix_indexed_assignment''''',
         imatrix_indexed_assignment'''''',
         imatrix_indexed_assignment''''''',
         imatrix_indexed_assignment'''''''',
         imatrix_indexed_assignment''''''''',
         imatrix_indexed_one_based_assignment,
         imatrix_indexed_one_based_assignment',
         imatrix_indexed_one_based_assignment'',
         imatrix_indexed_zero_based_assignment,
         imatrix_indexed_zero_based_assignment',
         imatrix_indexed_zero_based_assignment'',
         imatrix_inf,
         imatrix_inf',
         imatrix_inf'',
         imatrix_inf''',
         imatrix_isConstant,
         imatrix_isEqual,
         imatrix_isIdentity,
         imatrix_isInteger,
         imatrix_isMinusOne,
         imatrix_isOne,
         imatrix_isRegular,
         imatrix_isSmooth,
         imatrix_isSymbolic,
         imatrix_isSymbolicSparse,
         imatrix_isZero,
         imatrix_log,
         imatrix_log10,
         imatrix_logic_and,
         imatrix_logic_not,
         imatrix_logic_or,
         imatrix_matrix_matrix,
         imatrix_matrix_scalar,
         imatrix_mul,
         imatrix_mul',
         imatrix_mul_full,
         imatrix_mul_full',
         imatrix_mul_no_alloc_nn,
         imatrix_mul_no_alloc_nn',
         imatrix_mul_no_alloc_nt,
         imatrix_mul_no_alloc_tn,
         imatrix_mul_no_alloc_tn',
         imatrix_nan,
         imatrix_nan',
         imatrix_nan'',
         imatrix_nan''',
         imatrix_nz_indexed_assignment,
         imatrix_nz_indexed_assignment',
         imatrix_nz_indexed_one_based_assignment,
         imatrix_nz_indexed_one_based_assignment',
         imatrix_nz_indexed_zero_based_assignment,
         imatrix_nz_indexed_zero_based_assignment',
         imatrix_operator_minus,
         imatrix_operator_plus,
         imatrix_printDense',
         imatrix_printScalar',
         imatrix_printSparse',
         imatrix_printVector',
         imatrix_printme,
         imatrix_quad_form,
         imatrix_remove,
         imatrix_repmat,
         imatrix_repmat',
         imatrix_repmat'',
         imatrix_repmat''',
         imatrix_reserve,
         imatrix_reserve',
         imatrix_resize,
         imatrix_row,
         imatrix_sanityCheck,
         imatrix_sanityCheck',
         imatrix_scalar_matrix,
         imatrix_set,
         imatrix_set',
         imatrix_set'',
         imatrix_set''',
         imatrix_set'''',
         imatrix_set''''',
         imatrix_setAll,
         imatrix_setEqualityCheckingDepth,
         imatrix_setEqualityCheckingDepth',
         imatrix_setMaxNumCallsInPrint,
         imatrix_setMaxNumCallsInPrint',
         imatrix_setNZ,
         imatrix_setNZ',
         imatrix_setNZ'',
         imatrix_setNZ''',
         imatrix_setPrecision,
         imatrix_setScientific,
         imatrix_setSparse,
         imatrix_setSparse',
         imatrix_setSub,
         imatrix_setSub',
         imatrix_setSub'',
         imatrix_setSub''',
         imatrix_setSub'''',
         imatrix_setSub''''',
         imatrix_setSub'''''',
         imatrix_setSub''''''',
         imatrix_setSub'''''''',
         imatrix_setSub''''''''',
         imatrix_setSub'''''''''',
         imatrix_setSub''''''''''',
         imatrix_setSub'''''''''''',
         imatrix_setSub''''''''''''',
         imatrix_setWidth,
         imatrix_setZero,
         imatrix_sign,
         imatrix_sin,
         imatrix_sinh,
         imatrix_sparsify,
         imatrix_sparsify',
         imatrix_sparsityRef,
         imatrix_sqrt,
         imatrix_tan,
         imatrix_tanh,
         imatrix_trans,
         imatrix_triplet,
         imatrix_triplet',
         imatrix_unary,
       ) where


import Prelude hiding ( Functor )

import Data.Vector ( Vector )
import Foreign.C.Types
import Foreign.Ptr ( Ptr )
import Foreign.ForeignPtr ( newForeignPtr )
import System.IO.Unsafe ( unsafePerformIO ) -- for show instances

import Casadi.Wrappers.Classes.PrintableObject
import Casadi.Wrappers.CToolsInstances ( )
import Casadi.Wrappers.Data
import Casadi.Wrappers.Enums
import Casadi.MarshalTypes ( CppVec, StdString' ) -- StdOstream'
import Casadi.Marshal ( Marshal(..), withMarshal )
import Casadi.WrapReturn ( WrapReturn(..) )

instance Show IMatrix where
  show = unsafePerformIO . printableObject_getDescription
-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___sanityCheck" c_CasADi__Matrix_int___sanityCheck
  :: Ptr IMatrix' -> CInt -> IO ()
casADi__Matrix_int___sanityCheck
  :: IMatrix -> Bool -> IO ()
casADi__Matrix_int___sanityCheck x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_int___sanityCheck x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Check if the
>dimensions and colind,row vectors are compatible.
>
>Parameters:
>-----------
>
>complete:  set to true to also check elementwise throws an error as possible
>result
-}
imatrix_sanityCheck :: IMatrixClass a => a -> Bool -> IO ()
imatrix_sanityCheck x = casADi__Matrix_int___sanityCheck (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___sanityCheck_TIC" c_CasADi__Matrix_int___sanityCheck_TIC
  :: Ptr IMatrix' -> IO ()
casADi__Matrix_int___sanityCheck'
  :: IMatrix -> IO ()
casADi__Matrix_int___sanityCheck' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_int___sanityCheck_TIC x0' >>= wrapReturn

-- classy wrapper
imatrix_sanityCheck' :: IMatrixClass a => a -> IO ()
imatrix_sanityCheck' x = casADi__Matrix_int___sanityCheck' (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___at" c_CasADi__Matrix_int___at
  :: Ptr IMatrix' -> CInt -> IO CInt
casADi__Matrix_int___at
  :: IMatrix -> Int -> IO Int
casADi__Matrix_int___at x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_int___at x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>>  const DataType& CasADi::Matrix< T >::at(int k) const 
>------------------------------------------------------------------------
>[INTERNAL] 
>Get a non-zero element.
>
>>  DataType& CasADi::Matrix< T >::at(int k)
>------------------------------------------------------------------------
>[INTERNAL] 
>Access a non-zero element.
-}
imatrix_at :: IMatrixClass a => a -> Int -> IO Int
imatrix_at x = casADi__Matrix_int___at (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___elem" c_CasADi__Matrix_int___elem
  :: Ptr IMatrix' -> CInt -> CInt -> IO CInt
casADi__Matrix_int___elem
  :: IMatrix -> Int -> Int -> IO Int
casADi__Matrix_int___elem x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_int___elem x0' x1' x2' >>= wrapReturn

-- classy wrapper
{-|
>>  const DataType & CasADi::Matrix< DataType >::elem(int rr, int cc=0) const 
>------------------------------------------------------------------------
>[INTERNAL] 
>get an element
>
>>  DataType & CasADi::Matrix< DataType >::elem(int rr, int cc=0)
>------------------------------------------------------------------------
>[INTERNAL] 
>get a reference to an element
-}
imatrix_elem :: IMatrixClass a => a -> Int -> Int -> IO Int
imatrix_elem x = casADi__Matrix_int___elem (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___elem_TIC" c_CasADi__Matrix_int___elem_TIC
  :: Ptr IMatrix' -> CInt -> IO CInt
casADi__Matrix_int___elem'
  :: IMatrix -> Int -> IO Int
casADi__Matrix_int___elem' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_int___elem_TIC x0' x1' >>= wrapReturn

-- classy wrapper
imatrix_elem' :: IMatrixClass a => a -> Int -> IO Int
imatrix_elem' x = casADi__Matrix_int___elem' (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___hasNZ" c_CasADi__Matrix_int___hasNZ
  :: Ptr IMatrix' -> CInt -> CInt -> IO CInt
casADi__Matrix_int___hasNZ
  :: IMatrix -> Int -> Int -> IO Bool
casADi__Matrix_int___hasNZ x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_int___hasNZ x0' x1' x2' >>= wrapReturn

-- classy wrapper
{-|
>Returns true if the matrix has a non-zero at location rr,cc.
-}
imatrix_hasNZ :: IMatrixClass a => a -> Int -> Int -> IO Bool
imatrix_hasNZ x = casADi__Matrix_int___hasNZ (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int_____nonzero__" c_CasADi__Matrix_int_____nonzero__
  :: Ptr IMatrix' -> IO CInt
casADi__Matrix_int_____nonzero__
  :: IMatrix -> IO Bool
casADi__Matrix_int_____nonzero__ x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_int_____nonzero__ x0' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Returns the
>truth value of a Matrix.
-}
imatrix___nonzero__ :: IMatrixClass a => a -> IO Bool
imatrix___nonzero__ x = casADi__Matrix_int_____nonzero__ (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___setSub" c_CasADi__Matrix_int___setSub
  :: Ptr IMatrix' -> Ptr IMatrix' -> CInt -> CInt -> IO ()
casADi__Matrix_int___setSub
  :: IMatrix -> IMatrix -> Int -> Int -> IO ()
casADi__Matrix_int___setSub x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  c_CasADi__Matrix_int___setSub x0' x1' x2' x3' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Set a submatrix.
-}
imatrix_setSub :: IMatrixClass a => a -> IMatrix -> Int -> Int -> IO ()
imatrix_setSub x = casADi__Matrix_int___setSub (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___setSub_TIC" c_CasADi__Matrix_int___setSub_TIC
  :: Ptr IMatrix' -> Ptr IMatrix' -> Ptr (CppVec CInt) -> CInt -> IO ()
casADi__Matrix_int___setSub'
  :: IMatrix -> IMatrix -> Vector Int -> Int -> IO ()
casADi__Matrix_int___setSub' x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  c_CasADi__Matrix_int___setSub_TIC x0' x1' x2' x3' >>= wrapReturn

-- classy wrapper
imatrix_setSub' :: IMatrixClass a => a -> IMatrix -> Vector Int -> Int -> IO ()
imatrix_setSub' x = casADi__Matrix_int___setSub' (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___setSub_TIC_TIC" c_CasADi__Matrix_int___setSub_TIC_TIC
  :: Ptr IMatrix' -> Ptr IMatrix' -> CInt -> Ptr (CppVec CInt) -> IO ()
casADi__Matrix_int___setSub''
  :: IMatrix -> IMatrix -> Int -> Vector Int -> IO ()
casADi__Matrix_int___setSub'' x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  c_CasADi__Matrix_int___setSub_TIC_TIC x0' x1' x2' x3' >>= wrapReturn

-- classy wrapper
imatrix_setSub'' :: IMatrixClass a => a -> IMatrix -> Int -> Vector Int -> IO ()
imatrix_setSub'' x = casADi__Matrix_int___setSub'' (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___setSub_TIC_TIC_TIC" c_CasADi__Matrix_int___setSub_TIC_TIC_TIC
  :: Ptr IMatrix' -> Ptr IMatrix' -> Ptr (CppVec CInt) -> Ptr (CppVec CInt) -> IO ()
casADi__Matrix_int___setSub'''
  :: IMatrix -> IMatrix -> Vector Int -> Vector Int -> IO ()
casADi__Matrix_int___setSub''' x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  c_CasADi__Matrix_int___setSub_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn

-- classy wrapper
imatrix_setSub''' :: IMatrixClass a => a -> IMatrix -> Vector Int -> Vector Int -> IO ()
imatrix_setSub''' x = casADi__Matrix_int___setSub''' (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___setSub_TIC_TIC_TIC_TIC" c_CasADi__Matrix_int___setSub_TIC_TIC_TIC_TIC
  :: Ptr IMatrix' -> Ptr IMatrix' -> Ptr Slice' -> Ptr (CppVec CInt) -> IO ()
casADi__Matrix_int___setSub''''
  :: IMatrix -> IMatrix -> Slice -> Vector Int -> IO ()
casADi__Matrix_int___setSub'''' x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  c_CasADi__Matrix_int___setSub_TIC_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn

-- classy wrapper
imatrix_setSub'''' :: IMatrixClass a => a -> IMatrix -> Slice -> Vector Int -> IO ()
imatrix_setSub'''' x = casADi__Matrix_int___setSub'''' (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___setSub_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_int___setSub_TIC_TIC_TIC_TIC_TIC
  :: Ptr IMatrix' -> Ptr IMatrix' -> Ptr (CppVec CInt) -> Ptr Slice' -> IO ()
casADi__Matrix_int___setSub'''''
  :: IMatrix -> IMatrix -> Vector Int -> Slice -> IO ()
casADi__Matrix_int___setSub''''' x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  c_CasADi__Matrix_int___setSub_TIC_TIC_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn

-- classy wrapper
imatrix_setSub''''' :: IMatrixClass a => a -> IMatrix -> Vector Int -> Slice -> IO ()
imatrix_setSub''''' x = casADi__Matrix_int___setSub''''' (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___setSub_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_int___setSub_TIC_TIC_TIC_TIC_TIC_TIC
  :: Ptr IMatrix' -> Ptr IMatrix' -> Ptr Slice' -> Ptr Slice' -> IO ()
casADi__Matrix_int___setSub''''''
  :: IMatrix -> IMatrix -> Slice -> Slice -> IO ()
casADi__Matrix_int___setSub'''''' x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  c_CasADi__Matrix_int___setSub_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn

-- classy wrapper
imatrix_setSub'''''' :: IMatrixClass a => a -> IMatrix -> Slice -> Slice -> IO ()
imatrix_setSub'''''' x = casADi__Matrix_int___setSub'''''' (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_int___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC
  :: Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr (CppVec CInt) -> IO ()
casADi__Matrix_int___setSub'''''''
  :: IMatrix -> IMatrix -> IMatrix -> Vector Int -> IO ()
casADi__Matrix_int___setSub''''''' x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  c_CasADi__Matrix_int___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn

-- classy wrapper
imatrix_setSub''''''' :: IMatrixClass a => a -> IMatrix -> IMatrix -> Vector Int -> IO ()
imatrix_setSub''''''' x = casADi__Matrix_int___setSub''''''' (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_int___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC
  :: Ptr IMatrix' -> Ptr IMatrix' -> Ptr (CppVec CInt) -> Ptr IMatrix' -> IO ()
casADi__Matrix_int___setSub''''''''
  :: IMatrix -> IMatrix -> Vector Int -> IMatrix -> IO ()
casADi__Matrix_int___setSub'''''''' x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  c_CasADi__Matrix_int___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn

-- classy wrapper
imatrix_setSub'''''''' :: IMatrixClass a => a -> IMatrix -> Vector Int -> IMatrix -> IO ()
imatrix_setSub'''''''' x = casADi__Matrix_int___setSub'''''''' (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_int___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC
  :: Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr Slice' -> IO ()
casADi__Matrix_int___setSub'''''''''
  :: IMatrix -> IMatrix -> IMatrix -> Slice -> IO ()
casADi__Matrix_int___setSub''''''''' x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  c_CasADi__Matrix_int___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn

-- classy wrapper
imatrix_setSub''''''''' :: IMatrixClass a => a -> IMatrix -> IMatrix -> Slice -> IO ()
imatrix_setSub''''''''' x = casADi__Matrix_int___setSub''''''''' (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_int___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC
  :: Ptr IMatrix' -> Ptr IMatrix' -> Ptr Slice' -> Ptr IMatrix' -> IO ()
casADi__Matrix_int___setSub''''''''''
  :: IMatrix -> IMatrix -> Slice -> IMatrix -> IO ()
casADi__Matrix_int___setSub'''''''''' x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  c_CasADi__Matrix_int___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn

-- classy wrapper
imatrix_setSub'''''''''' :: IMatrixClass a => a -> IMatrix -> Slice -> IMatrix -> IO ()
imatrix_setSub'''''''''' x = casADi__Matrix_int___setSub'''''''''' (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_int___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC
  :: Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> IO ()
casADi__Matrix_int___setSub'''''''''''
  :: IMatrix -> IMatrix -> IMatrix -> IMatrix -> IO ()
casADi__Matrix_int___setSub''''''''''' x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  c_CasADi__Matrix_int___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn

-- classy wrapper
imatrix_setSub''''''''''' :: IMatrixClass a => a -> IMatrix -> IMatrix -> IMatrix -> IO ()
imatrix_setSub''''''''''' x = casADi__Matrix_int___setSub''''''''''' (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_int___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC
  :: Ptr IMatrix' -> Ptr IMatrix' -> Ptr Slice' -> CInt -> IO ()
casADi__Matrix_int___setSub''''''''''''
  :: IMatrix -> IMatrix -> Slice -> Int -> IO ()
casADi__Matrix_int___setSub'''''''''''' x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  c_CasADi__Matrix_int___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn

-- classy wrapper
imatrix_setSub'''''''''''' :: IMatrixClass a => a -> IMatrix -> Slice -> Int -> IO ()
imatrix_setSub'''''''''''' x = casADi__Matrix_int___setSub'''''''''''' (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_int___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC
  :: Ptr IMatrix' -> Ptr IMatrix' -> Ptr Sparsity' -> CInt -> IO ()
casADi__Matrix_int___setSub'''''''''''''
  :: IMatrix -> IMatrix -> Sparsity -> Int -> IO ()
casADi__Matrix_int___setSub''''''''''''' x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  c_CasADi__Matrix_int___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn

-- classy wrapper
imatrix_setSub''''''''''''' :: IMatrixClass a => a -> IMatrix -> Sparsity -> Int -> IO ()
imatrix_setSub''''''''''''' x = casADi__Matrix_int___setSub''''''''''''' (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___setNZ" c_CasADi__Matrix_int___setNZ
  :: Ptr IMatrix' -> CInt -> Ptr IMatrix' -> IO ()
casADi__Matrix_int___setNZ
  :: IMatrix -> Int -> IMatrix -> IO ()
casADi__Matrix_int___setNZ x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_int___setNZ x0' x1' x2' >>= wrapReturn

-- classy wrapper
{-|
>>  void CasADi::Matrix< DataType >::setNZ(int k, const Matrix< DataType > &m)
>
>>  void CasADi::Matrix< DataType >::setNZ(const std::vector< int > &k, const Matrix< DataType > &m)
>
>>  void CasADi::Matrix< DataType >::setNZ(const Matrix< int > &k, const Matrix< DataType > &m)
>------------------------------------------------------------------------
>[INTERNAL] 
>Set a set of nonzeros.
>
>>  void CasADi::Matrix< T >::setNZ(const Slice &k, const Matrix< DataType > &m)
>------------------------------------------------------------------------
>
>Set a set of nonzeros.
-}
imatrix_setNZ :: IMatrixClass a => a -> Int -> IMatrix -> IO ()
imatrix_setNZ x = casADi__Matrix_int___setNZ (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___setNZ_TIC" c_CasADi__Matrix_int___setNZ_TIC
  :: Ptr IMatrix' -> Ptr (CppVec CInt) -> Ptr IMatrix' -> IO ()
casADi__Matrix_int___setNZ'
  :: IMatrix -> Vector Int -> IMatrix -> IO ()
casADi__Matrix_int___setNZ' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_int___setNZ_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
imatrix_setNZ' :: IMatrixClass a => a -> Vector Int -> IMatrix -> IO ()
imatrix_setNZ' x = casADi__Matrix_int___setNZ' (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___setNZ_TIC_TIC" c_CasADi__Matrix_int___setNZ_TIC_TIC
  :: Ptr IMatrix' -> Ptr Slice' -> Ptr IMatrix' -> IO ()
casADi__Matrix_int___setNZ''
  :: IMatrix -> Slice -> IMatrix -> IO ()
casADi__Matrix_int___setNZ'' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_int___setNZ_TIC_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
imatrix_setNZ'' :: IMatrixClass a => a -> Slice -> IMatrix -> IO ()
imatrix_setNZ'' x = casADi__Matrix_int___setNZ'' (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___setNZ_TIC_TIC_TIC" c_CasADi__Matrix_int___setNZ_TIC_TIC_TIC
  :: Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> IO ()
casADi__Matrix_int___setNZ'''
  :: IMatrix -> IMatrix -> IMatrix -> IO ()
casADi__Matrix_int___setNZ''' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_int___setNZ_TIC_TIC_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
imatrix_setNZ''' :: IMatrixClass a => a -> IMatrix -> IMatrix -> IO ()
imatrix_setNZ''' x = casADi__Matrix_int___setNZ''' (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___append" c_CasADi__Matrix_int___append
  :: Ptr IMatrix' -> Ptr IMatrix' -> IO ()
casADi__Matrix_int___append
  :: IMatrix -> IMatrix -> IO ()
casADi__Matrix_int___append x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_int___append x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Append a matrix
>vertically (NOTE: only efficient if vector)
-}
imatrix_append :: IMatrixClass a => a -> IMatrix -> IO ()
imatrix_append x = casADi__Matrix_int___append (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___appendColumns" c_CasADi__Matrix_int___appendColumns
  :: Ptr IMatrix' -> Ptr IMatrix' -> IO ()
casADi__Matrix_int___appendColumns
  :: IMatrix -> IMatrix -> IO ()
casADi__Matrix_int___appendColumns x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_int___appendColumns x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Append a
>matrix horizontally.
-}
imatrix_appendColumns :: IMatrixClass a => a -> IMatrix -> IO ()
imatrix_appendColumns x = casADi__Matrix_int___appendColumns (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___nz_indexed_one_based_assignment" c_CasADi__Matrix_int___nz_indexed_one_based_assignment
  :: Ptr IMatrix' -> CInt -> CInt -> IO ()
casADi__Matrix_int___nz_indexed_one_based_assignment
  :: IMatrix -> Int -> Int -> IO ()
casADi__Matrix_int___nz_indexed_one_based_assignment x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_int___nz_indexed_one_based_assignment x0' x1' x2' >>= wrapReturn

-- classy wrapper
{-|
>>  void CasADi::Matrix< T >::nz_indexed_one_based_assignment(int k, const DataType &m)
>------------------------------------------------------------------------
>[INTERNAL] 
>set a non-zero
>
>>  void CasADi::Matrix< T >::nz_indexed_one_based_assignment(const Matrix< int > &k, const Matrix< DataType > &m)
>------------------------------------------------------------------------
>[INTERNAL] 
>Indexing for interfaced languages get a non-zero
-}
imatrix_nz_indexed_one_based_assignment :: IMatrixClass a => a -> Int -> Int -> IO ()
imatrix_nz_indexed_one_based_assignment x = casADi__Matrix_int___nz_indexed_one_based_assignment (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___nz_indexed_zero_based_assignment" c_CasADi__Matrix_int___nz_indexed_zero_based_assignment
  :: Ptr IMatrix' -> CInt -> CInt -> IO ()
casADi__Matrix_int___nz_indexed_zero_based_assignment
  :: IMatrix -> Int -> Int -> IO ()
casADi__Matrix_int___nz_indexed_zero_based_assignment x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_int___nz_indexed_zero_based_assignment x0' x1' x2' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Indexing for interfaced languages get a non-zero
-}
imatrix_nz_indexed_zero_based_assignment :: IMatrixClass a => a -> Int -> Int -> IO ()
imatrix_nz_indexed_zero_based_assignment x = casADi__Matrix_int___nz_indexed_zero_based_assignment (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___nz_indexed_assignment" c_CasADi__Matrix_int___nz_indexed_assignment
  :: Ptr IMatrix' -> Ptr Slice' -> Ptr IMatrix' -> IO ()
casADi__Matrix_int___nz_indexed_assignment
  :: IMatrix -> Slice -> IMatrix -> IO ()
casADi__Matrix_int___nz_indexed_assignment x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_int___nz_indexed_assignment x0' x1' x2' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]
>Indexing for interfaced languages get a non-zero
-}
imatrix_nz_indexed_assignment :: IMatrixClass a => a -> Slice -> IMatrix -> IO ()
imatrix_nz_indexed_assignment x = casADi__Matrix_int___nz_indexed_assignment (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___indexed_one_based_assignment" c_CasADi__Matrix_int___indexed_one_based_assignment
  :: Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> IO ()
casADi__Matrix_int___indexed_one_based_assignment
  :: IMatrix -> IMatrix -> IMatrix -> IO ()
casADi__Matrix_int___indexed_one_based_assignment x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_int___indexed_one_based_assignment x0' x1' x2' >>= wrapReturn

-- classy wrapper
{-|
>>  void CasADi::Matrix< T >::indexed_one_based_assignment(const Matrix< int > &k, const Matrix< DataType > &m)
>------------------------------------------------------------------------
>[INTERNAL] 
>Indexing for interfaced languages get a non-zero
>
>>  void CasADi::Matrix< T >::indexed_one_based_assignment(int rr, int cc, const DataType &m)
>------------------------------------------------------------------------
>[INTERNAL] 
>set a matrix element
>
>>  void CasADi::Matrix< T >::indexed_one_based_assignment(int rr, const DataType &m)
>------------------------------------------------------------------------
>[INTERNAL] 
>set a vector element
-}
imatrix_indexed_one_based_assignment :: IMatrixClass a => a -> IMatrix -> IMatrix -> IO ()
imatrix_indexed_one_based_assignment x = casADi__Matrix_int___indexed_one_based_assignment (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___indexed_zero_based_assignment" c_CasADi__Matrix_int___indexed_zero_based_assignment
  :: Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> IO ()
casADi__Matrix_int___indexed_zero_based_assignment
  :: IMatrix -> IMatrix -> IMatrix -> IO ()
casADi__Matrix_int___indexed_zero_based_assignment x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_int___indexed_zero_based_assignment x0' x1' x2' >>= wrapReturn

-- classy wrapper
{-|
>>  void CasADi::Matrix< T >::indexed_zero_based_assignment(const Matrix< int > &k, const Matrix< DataType > &m)
>
>>  void CasADi::Matrix< T >::indexed_zero_based_assignment(int rr, int cc, const DataType &m)
>------------------------------------------------------------------------
>[INTERNAL] 
>Indexing for interfaced languages get a non-zero
>
>>  void CasADi::Matrix< T >::indexed_zero_based_assignment(int rr, const DataType &m)
>------------------------------------------------------------------------
>[INTERNAL] 
-}
imatrix_indexed_zero_based_assignment :: IMatrixClass a => a -> IMatrix -> IMatrix -> IO ()
imatrix_indexed_zero_based_assignment x = casADi__Matrix_int___indexed_zero_based_assignment (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___nz_indexed_one_based_assignment_TIC" c_CasADi__Matrix_int___nz_indexed_one_based_assignment_TIC
  :: Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> IO ()
casADi__Matrix_int___nz_indexed_one_based_assignment'
  :: IMatrix -> IMatrix -> IMatrix -> IO ()
casADi__Matrix_int___nz_indexed_one_based_assignment' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_int___nz_indexed_one_based_assignment_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
imatrix_nz_indexed_one_based_assignment' :: IMatrixClass a => a -> IMatrix -> IMatrix -> IO ()
imatrix_nz_indexed_one_based_assignment' x = casADi__Matrix_int___nz_indexed_one_based_assignment' (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___nz_indexed_zero_based_assignment_TIC" c_CasADi__Matrix_int___nz_indexed_zero_based_assignment_TIC
  :: Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> IO ()
casADi__Matrix_int___nz_indexed_zero_based_assignment'
  :: IMatrix -> IMatrix -> IMatrix -> IO ()
casADi__Matrix_int___nz_indexed_zero_based_assignment' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_int___nz_indexed_zero_based_assignment_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
imatrix_nz_indexed_zero_based_assignment' :: IMatrixClass a => a -> IMatrix -> IMatrix -> IO ()
imatrix_nz_indexed_zero_based_assignment' x = casADi__Matrix_int___nz_indexed_zero_based_assignment' (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___nz_indexed_assignment_TIC" c_CasADi__Matrix_int___nz_indexed_assignment_TIC
  :: Ptr IMatrix' -> Ptr IndexList' -> Ptr IMatrix' -> IO ()
casADi__Matrix_int___nz_indexed_assignment'
  :: IMatrix -> IndexList -> IMatrix -> IO ()
casADi__Matrix_int___nz_indexed_assignment' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_int___nz_indexed_assignment_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
imatrix_nz_indexed_assignment' :: IMatrixClass a => a -> IndexList -> IMatrix -> IO ()
imatrix_nz_indexed_assignment' x = casADi__Matrix_int___nz_indexed_assignment' (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___indexed_one_based_assignment_TIC" c_CasADi__Matrix_int___indexed_one_based_assignment_TIC
  :: Ptr IMatrix' -> CInt -> CInt -> CInt -> IO ()
casADi__Matrix_int___indexed_one_based_assignment'
  :: IMatrix -> Int -> Int -> Int -> IO ()
casADi__Matrix_int___indexed_one_based_assignment' x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  c_CasADi__Matrix_int___indexed_one_based_assignment_TIC x0' x1' x2' x3' >>= wrapReturn

-- classy wrapper
imatrix_indexed_one_based_assignment' :: IMatrixClass a => a -> Int -> Int -> Int -> IO ()
imatrix_indexed_one_based_assignment' x = casADi__Matrix_int___indexed_one_based_assignment' (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___indexed_zero_based_assignment_TIC" c_CasADi__Matrix_int___indexed_zero_based_assignment_TIC
  :: Ptr IMatrix' -> CInt -> CInt -> CInt -> IO ()
casADi__Matrix_int___indexed_zero_based_assignment'
  :: IMatrix -> Int -> Int -> Int -> IO ()
casADi__Matrix_int___indexed_zero_based_assignment' x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  c_CasADi__Matrix_int___indexed_zero_based_assignment_TIC x0' x1' x2' x3' >>= wrapReturn

-- classy wrapper
imatrix_indexed_zero_based_assignment' :: IMatrixClass a => a -> Int -> Int -> Int -> IO ()
imatrix_indexed_zero_based_assignment' x = casADi__Matrix_int___indexed_zero_based_assignment' (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___indexed_assignment" c_CasADi__Matrix_int___indexed_assignment
  :: Ptr IMatrix' -> Ptr Slice' -> Ptr Slice' -> Ptr IMatrix' -> IO ()
casADi__Matrix_int___indexed_assignment
  :: IMatrix -> Slice -> Slice -> IMatrix -> IO ()
casADi__Matrix_int___indexed_assignment x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  c_CasADi__Matrix_int___indexed_assignment x0' x1' x2' x3' >>= wrapReturn

-- classy wrapper
{-|
>>  void CasADi::Matrix< T >::indexed_assignment(const Slice &rr, const Slice &cc, const Matrix< DataType > &m)
>
>>  void CasADi::Matrix< T >::indexed_assignment(const IndexList &rr, const IndexList &cc, const Matrix< DataType > &m)
>
>>  void CasADi::Matrix< T >::indexed_assignment(const Slice &rr, const Matrix< int > &cc, const Matrix< DataType > &m)
>
>>  void CasADi::Matrix< T >::indexed_assignment(const Matrix< int > &rr, const Slice &cc, const Matrix< DataType > &m)
>
>>  void CasADi::Matrix< T >::indexed_assignment(const Matrix< int > &rr, const IndexList &cc, const Matrix< DataType > &m)
>
>>  void CasADi::Matrix< T >::indexed_assignment(const IndexList &rr, const Matrix< int > &cc, const Matrix< DataType > &m)
>
>>  void CasADi::Matrix< T >::indexed_assignment(const Matrix< int > &rr, const Matrix< int > &cc, const Matrix< DataType > &m)
>
>>  void CasADi::Matrix< T >::indexed_assignment(const Sparsity &sp, const Matrix< DataType > &m)
>------------------------------------------------------------------------
>[INTERNAL] 
>Indexing for interfaced languages get a non-zero
>
>>  void CasADi::Matrix< T >::indexed_assignment(const Slice &rr, const Matrix< DataType > &m)
>
>>  void CasADi::Matrix< T >::indexed_assignment(const IndexList &rr, const Matrix< DataType > &m)
>------------------------------------------------------------------------
>[INTERNAL] 
-}
imatrix_indexed_assignment :: IMatrixClass a => a -> Slice -> Slice -> IMatrix -> IO ()
imatrix_indexed_assignment x = casADi__Matrix_int___indexed_assignment (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___indexed_assignment_TIC" c_CasADi__Matrix_int___indexed_assignment_TIC
  :: Ptr IMatrix' -> Ptr IndexList' -> Ptr IndexList' -> Ptr IMatrix' -> IO ()
casADi__Matrix_int___indexed_assignment'
  :: IMatrix -> IndexList -> IndexList -> IMatrix -> IO ()
casADi__Matrix_int___indexed_assignment' x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  c_CasADi__Matrix_int___indexed_assignment_TIC x0' x1' x2' x3' >>= wrapReturn

-- classy wrapper
imatrix_indexed_assignment' :: IMatrixClass a => a -> IndexList -> IndexList -> IMatrix -> IO ()
imatrix_indexed_assignment' x = casADi__Matrix_int___indexed_assignment' (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___indexed_assignment_TIC_TIC" c_CasADi__Matrix_int___indexed_assignment_TIC_TIC
  :: Ptr IMatrix' -> Ptr Slice' -> Ptr IMatrix' -> Ptr IMatrix' -> IO ()
casADi__Matrix_int___indexed_assignment''
  :: IMatrix -> Slice -> IMatrix -> IMatrix -> IO ()
casADi__Matrix_int___indexed_assignment'' x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  c_CasADi__Matrix_int___indexed_assignment_TIC_TIC x0' x1' x2' x3' >>= wrapReturn

-- classy wrapper
imatrix_indexed_assignment'' :: IMatrixClass a => a -> Slice -> IMatrix -> IMatrix -> IO ()
imatrix_indexed_assignment'' x = casADi__Matrix_int___indexed_assignment'' (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___indexed_assignment_TIC_TIC_TIC" c_CasADi__Matrix_int___indexed_assignment_TIC_TIC_TIC
  :: Ptr IMatrix' -> Ptr IMatrix' -> Ptr Slice' -> Ptr IMatrix' -> IO ()
casADi__Matrix_int___indexed_assignment'''
  :: IMatrix -> IMatrix -> Slice -> IMatrix -> IO ()
casADi__Matrix_int___indexed_assignment''' x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  c_CasADi__Matrix_int___indexed_assignment_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn

-- classy wrapper
imatrix_indexed_assignment''' :: IMatrixClass a => a -> IMatrix -> Slice -> IMatrix -> IO ()
imatrix_indexed_assignment''' x = casADi__Matrix_int___indexed_assignment''' (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___indexed_assignment_TIC_TIC_TIC_TIC" c_CasADi__Matrix_int___indexed_assignment_TIC_TIC_TIC_TIC
  :: Ptr IMatrix' -> Ptr IMatrix' -> Ptr IndexList' -> Ptr IMatrix' -> IO ()
casADi__Matrix_int___indexed_assignment''''
  :: IMatrix -> IMatrix -> IndexList -> IMatrix -> IO ()
casADi__Matrix_int___indexed_assignment'''' x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  c_CasADi__Matrix_int___indexed_assignment_TIC_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn

-- classy wrapper
imatrix_indexed_assignment'''' :: IMatrixClass a => a -> IMatrix -> IndexList -> IMatrix -> IO ()
imatrix_indexed_assignment'''' x = casADi__Matrix_int___indexed_assignment'''' (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___indexed_assignment_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_int___indexed_assignment_TIC_TIC_TIC_TIC_TIC
  :: Ptr IMatrix' -> Ptr IndexList' -> Ptr IMatrix' -> Ptr IMatrix' -> IO ()
casADi__Matrix_int___indexed_assignment'''''
  :: IMatrix -> IndexList -> IMatrix -> IMatrix -> IO ()
casADi__Matrix_int___indexed_assignment''''' x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  c_CasADi__Matrix_int___indexed_assignment_TIC_TIC_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn

-- classy wrapper
imatrix_indexed_assignment''''' :: IMatrixClass a => a -> IndexList -> IMatrix -> IMatrix -> IO ()
imatrix_indexed_assignment''''' x = casADi__Matrix_int___indexed_assignment''''' (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_int___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC
  :: Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> IO ()
casADi__Matrix_int___indexed_assignment''''''
  :: IMatrix -> IMatrix -> IMatrix -> IMatrix -> IO ()
casADi__Matrix_int___indexed_assignment'''''' x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  c_CasADi__Matrix_int___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn

-- classy wrapper
imatrix_indexed_assignment'''''' :: IMatrixClass a => a -> IMatrix -> IMatrix -> IMatrix -> IO ()
imatrix_indexed_assignment'''''' x = casADi__Matrix_int___indexed_assignment'''''' (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_int___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC
  :: Ptr IMatrix' -> Ptr Sparsity' -> Ptr IMatrix' -> IO ()
casADi__Matrix_int___indexed_assignment'''''''
  :: IMatrix -> Sparsity -> IMatrix -> IO ()
casADi__Matrix_int___indexed_assignment''''''' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_int___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
imatrix_indexed_assignment''''''' :: IMatrixClass a => a -> Sparsity -> IMatrix -> IO ()
imatrix_indexed_assignment''''''' x = casADi__Matrix_int___indexed_assignment''''''' (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___indexed_one_based_assignment_TIC_TIC" c_CasADi__Matrix_int___indexed_one_based_assignment_TIC_TIC
  :: Ptr IMatrix' -> CInt -> CInt -> IO ()
casADi__Matrix_int___indexed_one_based_assignment''
  :: IMatrix -> Int -> Int -> IO ()
casADi__Matrix_int___indexed_one_based_assignment'' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_int___indexed_one_based_assignment_TIC_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
imatrix_indexed_one_based_assignment'' :: IMatrixClass a => a -> Int -> Int -> IO ()
imatrix_indexed_one_based_assignment'' x = casADi__Matrix_int___indexed_one_based_assignment'' (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___indexed_zero_based_assignment_TIC_TIC" c_CasADi__Matrix_int___indexed_zero_based_assignment_TIC_TIC
  :: Ptr IMatrix' -> CInt -> CInt -> IO ()
casADi__Matrix_int___indexed_zero_based_assignment''
  :: IMatrix -> Int -> Int -> IO ()
casADi__Matrix_int___indexed_zero_based_assignment'' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_int___indexed_zero_based_assignment_TIC_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
imatrix_indexed_zero_based_assignment'' :: IMatrixClass a => a -> Int -> Int -> IO ()
imatrix_indexed_zero_based_assignment'' x = casADi__Matrix_int___indexed_zero_based_assignment'' (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_int___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC
  :: Ptr IMatrix' -> Ptr Slice' -> Ptr IMatrix' -> IO ()
casADi__Matrix_int___indexed_assignment''''''''
  :: IMatrix -> Slice -> IMatrix -> IO ()
casADi__Matrix_int___indexed_assignment'''''''' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_int___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
imatrix_indexed_assignment'''''''' :: IMatrixClass a => a -> Slice -> IMatrix -> IO ()
imatrix_indexed_assignment'''''''' x = casADi__Matrix_int___indexed_assignment'''''''' (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_int___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC
  :: Ptr IMatrix' -> Ptr IndexList' -> Ptr IMatrix' -> IO ()
casADi__Matrix_int___indexed_assignment'''''''''
  :: IMatrix -> IndexList -> IMatrix -> IO ()
casADi__Matrix_int___indexed_assignment''''''''' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_int___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
imatrix_indexed_assignment''''''''' :: IMatrixClass a => a -> IndexList -> IMatrix -> IO ()
imatrix_indexed_assignment''''''''' x = casADi__Matrix_int___indexed_assignment''''''''' (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___setZero" c_CasADi__Matrix_int___setZero
  :: Ptr IMatrix' -> IO ()
casADi__Matrix_int___setZero
  :: IMatrix -> IO ()
casADi__Matrix_int___setZero x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_int___setZero x0' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Set all elements
>to zero.
-}
imatrix_setZero :: IMatrixClass a => a -> IO ()
imatrix_setZero x = casADi__Matrix_int___setZero (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___setAll" c_CasADi__Matrix_int___setAll
  :: Ptr IMatrix' -> CInt -> IO ()
casADi__Matrix_int___setAll
  :: IMatrix -> Int -> IO ()
casADi__Matrix_int___setAll x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_int___setAll x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Set all elements
>to a value.
-}
imatrix_setAll :: IMatrixClass a => a -> Int -> IO ()
imatrix_setAll x = casADi__Matrix_int___setAll (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___setSparse" c_CasADi__Matrix_int___setSparse
  :: Ptr IMatrix' -> Ptr Sparsity' -> CInt -> IO (Ptr IMatrix')
casADi__Matrix_int___setSparse
  :: IMatrix -> Sparsity -> Bool -> IO IMatrix
casADi__Matrix_int___setSparse x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_int___setSparse x0' x1' x2' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Set sparse.
-}
imatrix_setSparse :: IMatrixClass a => a -> Sparsity -> Bool -> IO IMatrix
imatrix_setSparse x = casADi__Matrix_int___setSparse (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___setSparse_TIC" c_CasADi__Matrix_int___setSparse_TIC
  :: Ptr IMatrix' -> Ptr Sparsity' -> IO (Ptr IMatrix')
casADi__Matrix_int___setSparse'
  :: IMatrix -> Sparsity -> IO IMatrix
casADi__Matrix_int___setSparse' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_int___setSparse_TIC x0' x1' >>= wrapReturn

-- classy wrapper
imatrix_setSparse' :: IMatrixClass a => a -> Sparsity -> IO IMatrix
imatrix_setSparse' x = casADi__Matrix_int___setSparse' (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___densify" c_CasADi__Matrix_int___densify
  :: Ptr IMatrix' -> CInt -> IO ()
casADi__Matrix_int___densify
  :: IMatrix -> Int -> IO ()
casADi__Matrix_int___densify x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_int___densify x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Make the matrix
>dense.
-}
imatrix_densify :: IMatrixClass a => a -> Int -> IO ()
imatrix_densify x = casADi__Matrix_int___densify (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___densify_TIC" c_CasADi__Matrix_int___densify_TIC
  :: Ptr IMatrix' -> IO ()
casADi__Matrix_int___densify'
  :: IMatrix -> IO ()
casADi__Matrix_int___densify' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_int___densify_TIC x0' >>= wrapReturn

-- classy wrapper
imatrix_densify' :: IMatrixClass a => a -> IO ()
imatrix_densify' x = casADi__Matrix_int___densify' (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___sparsify" c_CasADi__Matrix_int___sparsify
  :: Ptr IMatrix' -> CDouble -> IO ()
casADi__Matrix_int___sparsify
  :: IMatrix -> Double -> IO ()
casADi__Matrix_int___sparsify x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_int___sparsify x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Make a matrix
>sparse by removing numerical zeros smaller in absolute value than a
>specified tolerance.
-}
imatrix_sparsify :: IMatrixClass a => a -> Double -> IO ()
imatrix_sparsify x = casADi__Matrix_int___sparsify (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___sparsify_TIC" c_CasADi__Matrix_int___sparsify_TIC
  :: Ptr IMatrix' -> IO ()
casADi__Matrix_int___sparsify'
  :: IMatrix -> IO ()
casADi__Matrix_int___sparsify' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_int___sparsify_TIC x0' >>= wrapReturn

-- classy wrapper
imatrix_sparsify' :: IMatrixClass a => a -> IO ()
imatrix_sparsify' x = casADi__Matrix_int___sparsify' (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___operator_plus" c_CasADi__Matrix_int___operator_plus
  :: Ptr IMatrix' -> IO (Ptr IMatrix')
casADi__Matrix_int___operator_plus
  :: IMatrix -> IO IMatrix
casADi__Matrix_int___operator_plus x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_int___operator_plus x0' >>= wrapReturn

-- classy wrapper
imatrix_operator_plus :: IMatrixClass a => a -> IO IMatrix
imatrix_operator_plus x = casADi__Matrix_int___operator_plus (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___operator_minus" c_CasADi__Matrix_int___operator_minus
  :: Ptr IMatrix' -> IO (Ptr IMatrix')
casADi__Matrix_int___operator_minus
  :: IMatrix -> IO IMatrix
casADi__Matrix_int___operator_minus x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_int___operator_minus x0' >>= wrapReturn

-- classy wrapper
imatrix_operator_minus :: IMatrixClass a => a -> IO IMatrix
imatrix_operator_minus x = casADi__Matrix_int___operator_minus (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___binary" c_CasADi__Matrix_int___binary
  :: CInt -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
casADi__Matrix_int___binary
  :: Int -> IMatrix -> IMatrix -> IO IMatrix
casADi__Matrix_int___binary x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_int___binary x0' x1' x2' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Create nodes by
>their ID.
-}
imatrix_binary :: Int -> IMatrix -> IMatrix -> IO IMatrix
imatrix_binary = casADi__Matrix_int___binary


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___unary" c_CasADi__Matrix_int___unary
  :: CInt -> Ptr IMatrix' -> IO (Ptr IMatrix')
casADi__Matrix_int___unary
  :: Int -> IMatrix -> IO IMatrix
casADi__Matrix_int___unary x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_int___unary x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Create nodes by
>their ID.
-}
imatrix_unary :: Int -> IMatrix -> IO IMatrix
imatrix_unary = casADi__Matrix_int___unary


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___scalar_matrix" c_CasADi__Matrix_int___scalar_matrix
  :: CInt -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
casADi__Matrix_int___scalar_matrix
  :: Int -> IMatrix -> IMatrix -> IO IMatrix
casADi__Matrix_int___scalar_matrix x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_int___scalar_matrix x0' x1' x2' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Create
>nodes by their ID.
-}
imatrix_scalar_matrix :: Int -> IMatrix -> IMatrix -> IO IMatrix
imatrix_scalar_matrix = casADi__Matrix_int___scalar_matrix


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___matrix_scalar" c_CasADi__Matrix_int___matrix_scalar
  :: CInt -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
casADi__Matrix_int___matrix_scalar
  :: Int -> IMatrix -> IMatrix -> IO IMatrix
casADi__Matrix_int___matrix_scalar x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_int___matrix_scalar x0' x1' x2' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Create
>nodes by their ID.
-}
imatrix_matrix_scalar :: Int -> IMatrix -> IMatrix -> IO IMatrix
imatrix_matrix_scalar = casADi__Matrix_int___matrix_scalar


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___matrix_matrix" c_CasADi__Matrix_int___matrix_matrix
  :: CInt -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
casADi__Matrix_int___matrix_matrix
  :: Int -> IMatrix -> IMatrix -> IO IMatrix
casADi__Matrix_int___matrix_matrix x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_int___matrix_matrix x0' x1' x2' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Create
>nodes by their ID.
-}
imatrix_matrix_matrix :: Int -> IMatrix -> IMatrix -> IO IMatrix
imatrix_matrix_matrix = casADi__Matrix_int___matrix_matrix


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int_____add__" c_CasADi__Matrix_int_____add__
  :: Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
casADi__Matrix_int_____add__
  :: IMatrix -> IMatrix -> IO IMatrix
casADi__Matrix_int_____add__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_int_____add__ x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Elementwise
>operations Octave/Python naming.
-}
imatrix___add__ :: IMatrixClass a => a -> IMatrix -> IO IMatrix
imatrix___add__ x = casADi__Matrix_int_____add__ (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int_____sub__" c_CasADi__Matrix_int_____sub__
  :: Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
casADi__Matrix_int_____sub__
  :: IMatrix -> IMatrix -> IO IMatrix
casADi__Matrix_int_____sub__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_int_____sub__ x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Elementwise
>operations Octave/Python naming.
-}
imatrix___sub__ :: IMatrixClass a => a -> IMatrix -> IO IMatrix
imatrix___sub__ x = casADi__Matrix_int_____sub__ (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int_____mul__" c_CasADi__Matrix_int_____mul__
  :: Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
casADi__Matrix_int_____mul__
  :: IMatrix -> IMatrix -> IO IMatrix
casADi__Matrix_int_____mul__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_int_____mul__ x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Elementwise
>operations Octave/Python naming.
-}
imatrix___mul__ :: IMatrixClass a => a -> IMatrix -> IO IMatrix
imatrix___mul__ x = casADi__Matrix_int_____mul__ (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int_____div__" c_CasADi__Matrix_int_____div__
  :: Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
casADi__Matrix_int_____div__
  :: IMatrix -> IMatrix -> IO IMatrix
casADi__Matrix_int_____div__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_int_____div__ x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Elementwise
>operations Octave/Python naming.
-}
imatrix___div__ :: IMatrixClass a => a -> IMatrix -> IO IMatrix
imatrix___div__ x = casADi__Matrix_int_____div__ (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int_____lt__" c_CasADi__Matrix_int_____lt__
  :: Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
casADi__Matrix_int_____lt__
  :: IMatrix -> IMatrix -> IO IMatrix
casADi__Matrix_int_____lt__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_int_____lt__ x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Elementwise
>operations Octave/Python naming.
-}
imatrix___lt__ :: IMatrixClass a => a -> IMatrix -> IO IMatrix
imatrix___lt__ x = casADi__Matrix_int_____lt__ (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int_____le__" c_CasADi__Matrix_int_____le__
  :: Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
casADi__Matrix_int_____le__
  :: IMatrix -> IMatrix -> IO IMatrix
casADi__Matrix_int_____le__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_int_____le__ x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Elementwise
>operations Octave/Python naming.
-}
imatrix___le__ :: IMatrixClass a => a -> IMatrix -> IO IMatrix
imatrix___le__ x = casADi__Matrix_int_____le__ (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int_____eq__" c_CasADi__Matrix_int_____eq__
  :: Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
casADi__Matrix_int_____eq__
  :: IMatrix -> IMatrix -> IO IMatrix
casADi__Matrix_int_____eq__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_int_____eq__ x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Elementwise
>operations Octave/Python naming.
-}
imatrix___eq__ :: IMatrixClass a => a -> IMatrix -> IO IMatrix
imatrix___eq__ x = casADi__Matrix_int_____eq__ (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int_____ne__" c_CasADi__Matrix_int_____ne__
  :: Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
casADi__Matrix_int_____ne__
  :: IMatrix -> IMatrix -> IO IMatrix
casADi__Matrix_int_____ne__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_int_____ne__ x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Elementwise
>operations Octave/Python naming.
-}
imatrix___ne__ :: IMatrixClass a => a -> IMatrix -> IO IMatrix
imatrix___ne__ x = casADi__Matrix_int_____ne__ (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int_____truediv__" c_CasADi__Matrix_int_____truediv__
  :: Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
casADi__Matrix_int_____truediv__
  :: IMatrix -> IMatrix -> IO IMatrix
casADi__Matrix_int_____truediv__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_int_____truediv__ x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Elementwise
>operations Octave/Python naming.
-}
imatrix___truediv__ :: IMatrixClass a => a -> IMatrix -> IO IMatrix
imatrix___truediv__ x = casADi__Matrix_int_____truediv__ (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int_____pow__" c_CasADi__Matrix_int_____pow__
  :: Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
casADi__Matrix_int_____pow__
  :: IMatrix -> IMatrix -> IO IMatrix
casADi__Matrix_int_____pow__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_int_____pow__ x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Elementwise
>operations Octave/Python naming.
-}
imatrix___pow__ :: IMatrixClass a => a -> IMatrix -> IO IMatrix
imatrix___pow__ x = casADi__Matrix_int_____pow__ (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int_____constpow__" c_CasADi__Matrix_int_____constpow__
  :: Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
casADi__Matrix_int_____constpow__
  :: IMatrix -> IMatrix -> IO IMatrix
casADi__Matrix_int_____constpow__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_int_____constpow__ x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Elementwise
>operations Octave/Python naming.
-}
imatrix___constpow__ :: IMatrixClass a => a -> IMatrix -> IO IMatrix
imatrix___constpow__ x = casADi__Matrix_int_____constpow__ (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int_____mpower__" c_CasADi__Matrix_int_____mpower__
  :: Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
casADi__Matrix_int_____mpower__
  :: IMatrix -> IMatrix -> IO IMatrix
casADi__Matrix_int_____mpower__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_int_____mpower__ x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Elementwise
>operations Octave/Python naming.
-}
imatrix___mpower__ :: IMatrixClass a => a -> IMatrix -> IO IMatrix
imatrix___mpower__ x = casADi__Matrix_int_____mpower__ (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int_____mrdivide__" c_CasADi__Matrix_int_____mrdivide__
  :: Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
casADi__Matrix_int_____mrdivide__
  :: IMatrix -> IMatrix -> IO IMatrix
casADi__Matrix_int_____mrdivide__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_int_____mrdivide__ x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Elementwise
>operations Octave/Python naming.
-}
imatrix___mrdivide__ :: IMatrixClass a => a -> IMatrix -> IO IMatrix
imatrix___mrdivide__ x = casADi__Matrix_int_____mrdivide__ (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___mul_full" c_CasADi__Matrix_int___mul_full
  :: Ptr IMatrix' -> Ptr IMatrix' -> Ptr Sparsity' -> IO (Ptr IMatrix')
casADi__Matrix_int___mul_full
  :: IMatrix -> IMatrix -> Sparsity -> IO IMatrix
casADi__Matrix_int___mul_full x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_int___mul_full x0' x1' x2' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Matrix-matrix
>product.
-}
imatrix_mul_full :: IMatrixClass a => a -> IMatrix -> Sparsity -> IO IMatrix
imatrix_mul_full x = casADi__Matrix_int___mul_full (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___mul_full_TIC" c_CasADi__Matrix_int___mul_full_TIC
  :: Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
casADi__Matrix_int___mul_full'
  :: IMatrix -> IMatrix -> IO IMatrix
casADi__Matrix_int___mul_full' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_int___mul_full_TIC x0' x1' >>= wrapReturn

-- classy wrapper
imatrix_mul_full' :: IMatrixClass a => a -> IMatrix -> IO IMatrix
imatrix_mul_full' x = casADi__Matrix_int___mul_full' (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___mul" c_CasADi__Matrix_int___mul
  :: Ptr IMatrix' -> Ptr IMatrix' -> Ptr Sparsity' -> IO (Ptr IMatrix')
casADi__Matrix_int___mul
  :: IMatrix -> IMatrix -> Sparsity -> IO IMatrix
casADi__Matrix_int___mul x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_int___mul x0' x1' x2' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Matrix-matrix
>product.
-}
imatrix_mul :: IMatrixClass a => a -> IMatrix -> Sparsity -> IO IMatrix
imatrix_mul x = casADi__Matrix_int___mul (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___mul_TIC" c_CasADi__Matrix_int___mul_TIC
  :: Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
casADi__Matrix_int___mul'
  :: IMatrix -> IMatrix -> IO IMatrix
casADi__Matrix_int___mul' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_int___mul_TIC x0' x1' >>= wrapReturn

-- classy wrapper
imatrix_mul' :: IMatrixClass a => a -> IMatrix -> IO IMatrix
imatrix_mul' x = casADi__Matrix_int___mul' (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___mul_no_alloc_nn" c_CasADi__Matrix_int___mul_no_alloc_nn
  :: Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> IO ()
casADi__Matrix_int___mul_no_alloc_nn
  :: IMatrix -> IMatrix -> IMatrix -> IO ()
casADi__Matrix_int___mul_no_alloc_nn x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_int___mul_no_alloc_nn x0' x1' x2' >>= wrapReturn

-- classy wrapper
imatrix_mul_no_alloc_nn :: IMatrix -> IMatrix -> IMatrix -> IO ()
imatrix_mul_no_alloc_nn = casADi__Matrix_int___mul_no_alloc_nn


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___mul_no_alloc_tn" c_CasADi__Matrix_int___mul_no_alloc_tn
  :: Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> IO ()
casADi__Matrix_int___mul_no_alloc_tn
  :: IMatrix -> IMatrix -> IMatrix -> IO ()
casADi__Matrix_int___mul_no_alloc_tn x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_int___mul_no_alloc_tn x0' x1' x2' >>= wrapReturn

-- classy wrapper
imatrix_mul_no_alloc_tn :: IMatrix -> IMatrix -> IMatrix -> IO ()
imatrix_mul_no_alloc_tn = casADi__Matrix_int___mul_no_alloc_tn


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___mul_no_alloc_nt" c_CasADi__Matrix_int___mul_no_alloc_nt
  :: Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> IO ()
casADi__Matrix_int___mul_no_alloc_nt
  :: IMatrix -> IMatrix -> IMatrix -> IO ()
casADi__Matrix_int___mul_no_alloc_nt x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_int___mul_no_alloc_nt x0' x1' x2' >>= wrapReturn

-- classy wrapper
imatrix_mul_no_alloc_nt :: IMatrix -> IMatrix -> IMatrix -> IO ()
imatrix_mul_no_alloc_nt = casADi__Matrix_int___mul_no_alloc_nt


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___mul_no_alloc_tn_TIC" c_CasADi__Matrix_int___mul_no_alloc_tn_TIC
  :: Ptr IMatrix' -> Ptr (CppVec CInt) -> Ptr (CppVec CInt) -> IO ()
casADi__Matrix_int___mul_no_alloc_tn'
  :: IMatrix -> Vector Int -> Vector Int -> IO ()
casADi__Matrix_int___mul_no_alloc_tn' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_int___mul_no_alloc_tn_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
imatrix_mul_no_alloc_tn' :: IMatrix -> Vector Int -> Vector Int -> IO ()
imatrix_mul_no_alloc_tn' = casADi__Matrix_int___mul_no_alloc_tn'


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___mul_no_alloc_nn_TIC" c_CasADi__Matrix_int___mul_no_alloc_nn_TIC
  :: Ptr IMatrix' -> Ptr (CppVec CInt) -> Ptr (CppVec CInt) -> IO ()
casADi__Matrix_int___mul_no_alloc_nn'
  :: IMatrix -> Vector Int -> Vector Int -> IO ()
casADi__Matrix_int___mul_no_alloc_nn' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_int___mul_no_alloc_nn_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
imatrix_mul_no_alloc_nn' :: IMatrix -> Vector Int -> Vector Int -> IO ()
imatrix_mul_no_alloc_nn' = casADi__Matrix_int___mul_no_alloc_nn'


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___quad_form" c_CasADi__Matrix_int___quad_form
  :: Ptr IMatrix' -> Ptr (CppVec CInt) -> IO CInt
casADi__Matrix_int___quad_form
  :: IMatrix -> Vector Int -> IO Int
casADi__Matrix_int___quad_form x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_int___quad_form x0' x1' >>= wrapReturn

-- classy wrapper
imatrix_quad_form :: IMatrix -> Vector Int -> IO Int
imatrix_quad_form = casADi__Matrix_int___quad_form


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___trans" c_CasADi__Matrix_int___trans
  :: Ptr IMatrix' -> IO (Ptr IMatrix')
casADi__Matrix_int___trans
  :: IMatrix -> IO IMatrix
casADi__Matrix_int___trans x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_int___trans x0' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]   Transpose the
>matrix.
-}
imatrix_trans :: IMatrixClass a => a -> IO IMatrix
imatrix_trans x = casADi__Matrix_int___trans (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___sin" c_CasADi__Matrix_int___sin
  :: Ptr IMatrix' -> IO (Ptr IMatrix')
casADi__Matrix_int___sin
  :: IMatrix -> IO IMatrix
casADi__Matrix_int___sin x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_int___sin x0' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Operations defined
>in the standard namespace for unambigous access and Numpy compatibility.
-}
imatrix_sin :: IMatrixClass a => a -> IO IMatrix
imatrix_sin x = casADi__Matrix_int___sin (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___cos" c_CasADi__Matrix_int___cos
  :: Ptr IMatrix' -> IO (Ptr IMatrix')
casADi__Matrix_int___cos
  :: IMatrix -> IO IMatrix
casADi__Matrix_int___cos x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_int___cos x0' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Operations defined
>in the standard namespace for unambigous access and Numpy compatibility.
-}
imatrix_cos :: IMatrixClass a => a -> IO IMatrix
imatrix_cos x = casADi__Matrix_int___cos (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___tan" c_CasADi__Matrix_int___tan
  :: Ptr IMatrix' -> IO (Ptr IMatrix')
casADi__Matrix_int___tan
  :: IMatrix -> IO IMatrix
casADi__Matrix_int___tan x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_int___tan x0' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Operations defined
>in the standard namespace for unambigous access and Numpy compatibility.
-}
imatrix_tan :: IMatrixClass a => a -> IO IMatrix
imatrix_tan x = casADi__Matrix_int___tan (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___arcsin" c_CasADi__Matrix_int___arcsin
  :: Ptr IMatrix' -> IO (Ptr IMatrix')
casADi__Matrix_int___arcsin
  :: IMatrix -> IO IMatrix
casADi__Matrix_int___arcsin x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_int___arcsin x0' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Operations
>defined in the standard namespace for unambigous access and Numpy
>compatibility.
-}
imatrix_arcsin :: IMatrixClass a => a -> IO IMatrix
imatrix_arcsin x = casADi__Matrix_int___arcsin (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___arccos" c_CasADi__Matrix_int___arccos
  :: Ptr IMatrix' -> IO (Ptr IMatrix')
casADi__Matrix_int___arccos
  :: IMatrix -> IO IMatrix
casADi__Matrix_int___arccos x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_int___arccos x0' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Operations
>defined in the standard namespace for unambigous access and Numpy
>compatibility.
-}
imatrix_arccos :: IMatrixClass a => a -> IO IMatrix
imatrix_arccos x = casADi__Matrix_int___arccos (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___arctan" c_CasADi__Matrix_int___arctan
  :: Ptr IMatrix' -> IO (Ptr IMatrix')
casADi__Matrix_int___arctan
  :: IMatrix -> IO IMatrix
casADi__Matrix_int___arctan x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_int___arctan x0' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Operations
>defined in the standard namespace for unambigous access and Numpy
>compatibility.
-}
imatrix_arctan :: IMatrixClass a => a -> IO IMatrix
imatrix_arctan x = casADi__Matrix_int___arctan (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___exp" c_CasADi__Matrix_int___exp
  :: Ptr IMatrix' -> IO (Ptr IMatrix')
casADi__Matrix_int___exp
  :: IMatrix -> IO IMatrix
casADi__Matrix_int___exp x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_int___exp x0' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Operations defined
>in the standard namespace for unambigous access and Numpy compatibility.
-}
imatrix_exp :: IMatrixClass a => a -> IO IMatrix
imatrix_exp x = casADi__Matrix_int___exp (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___log" c_CasADi__Matrix_int___log
  :: Ptr IMatrix' -> IO (Ptr IMatrix')
casADi__Matrix_int___log
  :: IMatrix -> IO IMatrix
casADi__Matrix_int___log x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_int___log x0' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Operations defined
>in the standard namespace for unambigous access and Numpy compatibility.
-}
imatrix_log :: IMatrixClass a => a -> IO IMatrix
imatrix_log x = casADi__Matrix_int___log (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___sqrt" c_CasADi__Matrix_int___sqrt
  :: Ptr IMatrix' -> IO (Ptr IMatrix')
casADi__Matrix_int___sqrt
  :: IMatrix -> IO IMatrix
casADi__Matrix_int___sqrt x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_int___sqrt x0' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Operations defined
>in the standard namespace for unambigous access and Numpy compatibility.
-}
imatrix_sqrt :: IMatrixClass a => a -> IO IMatrix
imatrix_sqrt x = casADi__Matrix_int___sqrt (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___floor" c_CasADi__Matrix_int___floor
  :: Ptr IMatrix' -> IO (Ptr IMatrix')
casADi__Matrix_int___floor
  :: IMatrix -> IO IMatrix
casADi__Matrix_int___floor x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_int___floor x0' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Operations defined
>in the standard namespace for unambigous access and Numpy compatibility.
-}
imatrix_floor :: IMatrixClass a => a -> IO IMatrix
imatrix_floor x = casADi__Matrix_int___floor (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___ceil" c_CasADi__Matrix_int___ceil
  :: Ptr IMatrix' -> IO (Ptr IMatrix')
casADi__Matrix_int___ceil
  :: IMatrix -> IO IMatrix
casADi__Matrix_int___ceil x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_int___ceil x0' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Operations defined
>in the standard namespace for unambigous access and Numpy compatibility.
-}
imatrix_ceil :: IMatrixClass a => a -> IO IMatrix
imatrix_ceil x = casADi__Matrix_int___ceil (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___fabs" c_CasADi__Matrix_int___fabs
  :: Ptr IMatrix' -> IO (Ptr IMatrix')
casADi__Matrix_int___fabs
  :: IMatrix -> IO IMatrix
casADi__Matrix_int___fabs x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_int___fabs x0' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Operations defined
>in the standard namespace for unambigous access and Numpy compatibility.
-}
imatrix_fabs :: IMatrixClass a => a -> IO IMatrix
imatrix_fabs x = casADi__Matrix_int___fabs (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___sign" c_CasADi__Matrix_int___sign
  :: Ptr IMatrix' -> IO (Ptr IMatrix')
casADi__Matrix_int___sign
  :: IMatrix -> IO IMatrix
casADi__Matrix_int___sign x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_int___sign x0' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Operations defined
>in the standard namespace for unambigous access and Numpy compatibility.
-}
imatrix_sign :: IMatrixClass a => a -> IO IMatrix
imatrix_sign x = casADi__Matrix_int___sign (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int_____copysign__" c_CasADi__Matrix_int_____copysign__
  :: Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
casADi__Matrix_int_____copysign__
  :: IMatrix -> IMatrix -> IO IMatrix
casADi__Matrix_int_____copysign__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_int_____copysign__ x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Operations
>defined in the standard namespace for unambigous access and Numpy
>compatibility.
-}
imatrix___copysign__ :: IMatrixClass a => a -> IMatrix -> IO IMatrix
imatrix___copysign__ x = casADi__Matrix_int_____copysign__ (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___erfinv" c_CasADi__Matrix_int___erfinv
  :: Ptr IMatrix' -> IO (Ptr IMatrix')
casADi__Matrix_int___erfinv
  :: IMatrix -> IO IMatrix
casADi__Matrix_int___erfinv x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_int___erfinv x0' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Operations
>defined in the standard namespace for unambigous access and Numpy
>compatibility.
-}
imatrix_erfinv :: IMatrixClass a => a -> IO IMatrix
imatrix_erfinv x = casADi__Matrix_int___erfinv (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___fmin" c_CasADi__Matrix_int___fmin
  :: Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
casADi__Matrix_int___fmin
  :: IMatrix -> IMatrix -> IO IMatrix
casADi__Matrix_int___fmin x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_int___fmin x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Operations defined
>in the standard namespace for unambigous access and Numpy compatibility.
-}
imatrix_fmin :: IMatrixClass a => a -> IMatrix -> IO IMatrix
imatrix_fmin x = casADi__Matrix_int___fmin (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___fmax" c_CasADi__Matrix_int___fmax
  :: Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
casADi__Matrix_int___fmax
  :: IMatrix -> IMatrix -> IO IMatrix
casADi__Matrix_int___fmax x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_int___fmax x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Operations defined
>in the standard namespace for unambigous access and Numpy compatibility.
-}
imatrix_fmax :: IMatrixClass a => a -> IMatrix -> IO IMatrix
imatrix_fmax x = casADi__Matrix_int___fmax (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___erf" c_CasADi__Matrix_int___erf
  :: Ptr IMatrix' -> IO (Ptr IMatrix')
casADi__Matrix_int___erf
  :: IMatrix -> IO IMatrix
casADi__Matrix_int___erf x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_int___erf x0' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Operations defined
>in the standard namespace for unambigous access and Numpy compatibility.
-}
imatrix_erf :: IMatrixClass a => a -> IO IMatrix
imatrix_erf x = casADi__Matrix_int___erf (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___sinh" c_CasADi__Matrix_int___sinh
  :: Ptr IMatrix' -> IO (Ptr IMatrix')
casADi__Matrix_int___sinh
  :: IMatrix -> IO IMatrix
casADi__Matrix_int___sinh x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_int___sinh x0' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Operations defined
>in the standard namespace for unambigous access and Numpy compatibility.
-}
imatrix_sinh :: IMatrixClass a => a -> IO IMatrix
imatrix_sinh x = casADi__Matrix_int___sinh (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___cosh" c_CasADi__Matrix_int___cosh
  :: Ptr IMatrix' -> IO (Ptr IMatrix')
casADi__Matrix_int___cosh
  :: IMatrix -> IO IMatrix
casADi__Matrix_int___cosh x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_int___cosh x0' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Operations defined
>in the standard namespace for unambigous access and Numpy compatibility.
-}
imatrix_cosh :: IMatrixClass a => a -> IO IMatrix
imatrix_cosh x = casADi__Matrix_int___cosh (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___tanh" c_CasADi__Matrix_int___tanh
  :: Ptr IMatrix' -> IO (Ptr IMatrix')
casADi__Matrix_int___tanh
  :: IMatrix -> IO IMatrix
casADi__Matrix_int___tanh x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_int___tanh x0' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Operations defined
>in the standard namespace for unambigous access and Numpy compatibility.
-}
imatrix_tanh :: IMatrixClass a => a -> IO IMatrix
imatrix_tanh x = casADi__Matrix_int___tanh (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___arcsinh" c_CasADi__Matrix_int___arcsinh
  :: Ptr IMatrix' -> IO (Ptr IMatrix')
casADi__Matrix_int___arcsinh
  :: IMatrix -> IO IMatrix
casADi__Matrix_int___arcsinh x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_int___arcsinh x0' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Operations
>defined in the standard namespace for unambigous access and Numpy
>compatibility.
-}
imatrix_arcsinh :: IMatrixClass a => a -> IO IMatrix
imatrix_arcsinh x = casADi__Matrix_int___arcsinh (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___arccosh" c_CasADi__Matrix_int___arccosh
  :: Ptr IMatrix' -> IO (Ptr IMatrix')
casADi__Matrix_int___arccosh
  :: IMatrix -> IO IMatrix
casADi__Matrix_int___arccosh x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_int___arccosh x0' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Operations
>defined in the standard namespace for unambigous access and Numpy
>compatibility.
-}
imatrix_arccosh :: IMatrixClass a => a -> IO IMatrix
imatrix_arccosh x = casADi__Matrix_int___arccosh (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___arctanh" c_CasADi__Matrix_int___arctanh
  :: Ptr IMatrix' -> IO (Ptr IMatrix')
casADi__Matrix_int___arctanh
  :: IMatrix -> IO IMatrix
casADi__Matrix_int___arctanh x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_int___arctanh x0' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Operations
>defined in the standard namespace for unambigous access and Numpy
>compatibility.
-}
imatrix_arctanh :: IMatrixClass a => a -> IO IMatrix
imatrix_arctanh x = casADi__Matrix_int___arctanh (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___arctan2" c_CasADi__Matrix_int___arctan2
  :: Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
casADi__Matrix_int___arctan2
  :: IMatrix -> IMatrix -> IO IMatrix
casADi__Matrix_int___arctan2 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_int___arctan2 x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Operations
>defined in the standard namespace for unambigous access and Numpy
>compatibility.
-}
imatrix_arctan2 :: IMatrixClass a => a -> IMatrix -> IO IMatrix
imatrix_arctan2 x = casADi__Matrix_int___arctan2 (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___log10" c_CasADi__Matrix_int___log10
  :: Ptr IMatrix' -> IO (Ptr IMatrix')
casADi__Matrix_int___log10
  :: IMatrix -> IO IMatrix
casADi__Matrix_int___log10 x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_int___log10 x0' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Operations defined
>in the standard namespace for unambigous access and Numpy compatibility.
-}
imatrix_log10 :: IMatrixClass a => a -> IO IMatrix
imatrix_log10 x = casADi__Matrix_int___log10 (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___printme" c_CasADi__Matrix_int___printme
  :: Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
casADi__Matrix_int___printme
  :: IMatrix -> IMatrix -> IO IMatrix
casADi__Matrix_int___printme x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_int___printme x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Operations
>defined in the standard namespace for unambigous access and Numpy
>compatibility.
-}
imatrix_printme :: IMatrixClass a => a -> IMatrix -> IO IMatrix
imatrix_printme x = casADi__Matrix_int___printme (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___logic_not" c_CasADi__Matrix_int___logic_not
  :: Ptr IMatrix' -> IO (Ptr IMatrix')
casADi__Matrix_int___logic_not
  :: IMatrix -> IO IMatrix
casADi__Matrix_int___logic_not x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_int___logic_not x0' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Operations
>defined in the standard namespace for unambigous access and Numpy
>compatibility.
-}
imatrix_logic_not :: IMatrixClass a => a -> IO IMatrix
imatrix_logic_not x = casADi__Matrix_int___logic_not (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___logic_and" c_CasADi__Matrix_int___logic_and
  :: Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
casADi__Matrix_int___logic_and
  :: IMatrix -> IMatrix -> IO IMatrix
casADi__Matrix_int___logic_and x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_int___logic_and x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Operations
>defined in the standard namespace for unambigous access and Numpy
>compatibility.
-}
imatrix_logic_and :: IMatrixClass a => a -> IMatrix -> IO IMatrix
imatrix_logic_and x = casADi__Matrix_int___logic_and (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___logic_or" c_CasADi__Matrix_int___logic_or
  :: Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
casADi__Matrix_int___logic_or
  :: IMatrix -> IMatrix -> IO IMatrix
casADi__Matrix_int___logic_or x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_int___logic_or x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Operations
>defined in the standard namespace for unambigous access and Numpy
>compatibility.
-}
imatrix_logic_or :: IMatrixClass a => a -> IMatrix -> IO IMatrix
imatrix_logic_or x = casADi__Matrix_int___logic_or (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___if_else_zero" c_CasADi__Matrix_int___if_else_zero
  :: Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
casADi__Matrix_int___if_else_zero
  :: IMatrix -> IMatrix -> IO IMatrix
casADi__Matrix_int___if_else_zero x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_int___if_else_zero x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Operations
>defined in the standard namespace for unambigous access and Numpy
>compatibility.
-}
imatrix_if_else_zero :: IMatrixClass a => a -> IMatrix -> IO IMatrix
imatrix_if_else_zero x = casADi__Matrix_int___if_else_zero (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___setMaxNumCallsInPrint" c_CasADi__Matrix_int___setMaxNumCallsInPrint
  :: CLong -> IO ()
casADi__Matrix_int___setMaxNumCallsInPrint
  :: Int -> IO ()
casADi__Matrix_int___setMaxNumCallsInPrint x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_int___setMaxNumCallsInPrint x0' >>= wrapReturn

-- classy wrapper
imatrix_setMaxNumCallsInPrint :: Int -> IO ()
imatrix_setMaxNumCallsInPrint = casADi__Matrix_int___setMaxNumCallsInPrint


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___setMaxNumCallsInPrint_TIC" c_CasADi__Matrix_int___setMaxNumCallsInPrint_TIC
  :: IO ()
casADi__Matrix_int___setMaxNumCallsInPrint'
  :: IO ()
casADi__Matrix_int___setMaxNumCallsInPrint'  =
  c_CasADi__Matrix_int___setMaxNumCallsInPrint_TIC  >>= wrapReturn

-- classy wrapper
imatrix_setMaxNumCallsInPrint' :: IO ()
imatrix_setMaxNumCallsInPrint' = casADi__Matrix_int___setMaxNumCallsInPrint'


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___getMaxNumCallsInPrint" c_CasADi__Matrix_int___getMaxNumCallsInPrint
  :: IO CLong
casADi__Matrix_int___getMaxNumCallsInPrint
  :: IO Int
casADi__Matrix_int___getMaxNumCallsInPrint  =
  c_CasADi__Matrix_int___getMaxNumCallsInPrint  >>= wrapReturn

-- classy wrapper
imatrix_getMaxNumCallsInPrint :: IO Int
imatrix_getMaxNumCallsInPrint = casADi__Matrix_int___getMaxNumCallsInPrint


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___setEqualityCheckingDepth" c_CasADi__Matrix_int___setEqualityCheckingDepth
  :: CInt -> IO ()
casADi__Matrix_int___setEqualityCheckingDepth
  :: Int -> IO ()
casADi__Matrix_int___setEqualityCheckingDepth x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_int___setEqualityCheckingDepth x0' >>= wrapReturn

-- classy wrapper
imatrix_setEqualityCheckingDepth :: Int -> IO ()
imatrix_setEqualityCheckingDepth = casADi__Matrix_int___setEqualityCheckingDepth


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___setEqualityCheckingDepth_TIC" c_CasADi__Matrix_int___setEqualityCheckingDepth_TIC
  :: IO ()
casADi__Matrix_int___setEqualityCheckingDepth'
  :: IO ()
casADi__Matrix_int___setEqualityCheckingDepth'  =
  c_CasADi__Matrix_int___setEqualityCheckingDepth_TIC  >>= wrapReturn

-- classy wrapper
imatrix_setEqualityCheckingDepth' :: IO ()
imatrix_setEqualityCheckingDepth' = casADi__Matrix_int___setEqualityCheckingDepth'


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___getEqualityCheckingDepth" c_CasADi__Matrix_int___getEqualityCheckingDepth
  :: IO CInt
casADi__Matrix_int___getEqualityCheckingDepth
  :: IO Int
casADi__Matrix_int___getEqualityCheckingDepth  =
  c_CasADi__Matrix_int___getEqualityCheckingDepth  >>= wrapReturn

-- classy wrapper
imatrix_getEqualityCheckingDepth :: IO Int
imatrix_getEqualityCheckingDepth = casADi__Matrix_int___getEqualityCheckingDepth


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___className" c_CasADi__Matrix_int___className
  :: IO (Ptr StdString')
casADi__Matrix_int___className
  :: IO String
casADi__Matrix_int___className  =
  c_CasADi__Matrix_int___className  >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Printing.
-}
imatrix_className :: IO String
imatrix_className = casADi__Matrix_int___className


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___printScalar_TIC" c_CasADi__Matrix_int___printScalar_TIC
  :: Ptr IMatrix' -> IO ()
casADi__Matrix_int___printScalar'
  :: IMatrix -> IO ()
casADi__Matrix_int___printScalar' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_int___printScalar_TIC x0' >>= wrapReturn

-- classy wrapper
imatrix_printScalar' :: IMatrixClass a => a -> IO ()
imatrix_printScalar' x = casADi__Matrix_int___printScalar' (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___printVector_TIC" c_CasADi__Matrix_int___printVector_TIC
  :: Ptr IMatrix' -> IO ()
casADi__Matrix_int___printVector'
  :: IMatrix -> IO ()
casADi__Matrix_int___printVector' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_int___printVector_TIC x0' >>= wrapReturn

-- classy wrapper
imatrix_printVector' :: IMatrixClass a => a -> IO ()
imatrix_printVector' x = casADi__Matrix_int___printVector' (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___printDense_TIC" c_CasADi__Matrix_int___printDense_TIC
  :: Ptr IMatrix' -> IO ()
casADi__Matrix_int___printDense'
  :: IMatrix -> IO ()
casADi__Matrix_int___printDense' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_int___printDense_TIC x0' >>= wrapReturn

-- classy wrapper
imatrix_printDense' :: IMatrixClass a => a -> IO ()
imatrix_printDense' x = casADi__Matrix_int___printDense' (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___printSparse_TIC" c_CasADi__Matrix_int___printSparse_TIC
  :: Ptr IMatrix' -> IO ()
casADi__Matrix_int___printSparse'
  :: IMatrix -> IO ()
casADi__Matrix_int___printSparse' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_int___printSparse_TIC x0' >>= wrapReturn

-- classy wrapper
imatrix_printSparse' :: IMatrixClass a => a -> IO ()
imatrix_printSparse' x = casADi__Matrix_int___printSparse' (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___row" c_CasADi__Matrix_int___row
  :: Ptr IMatrix' -> CInt -> IO CInt
casADi__Matrix_int___row
  :: IMatrix -> Int -> IO Int
casADi__Matrix_int___row x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_int___row x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL] 
-}
imatrix_row :: IMatrixClass a => a -> Int -> IO Int
imatrix_row x = casADi__Matrix_int___row (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___colind" c_CasADi__Matrix_int___colind
  :: Ptr IMatrix' -> CInt -> IO CInt
casADi__Matrix_int___colind
  :: IMatrix -> Int -> IO Int
casADi__Matrix_int___colind x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_int___colind x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL] 
-}
imatrix_colind :: IMatrixClass a => a -> Int -> IO Int
imatrix_colind x = casADi__Matrix_int___colind (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___clear" c_CasADi__Matrix_int___clear
  :: Ptr IMatrix' -> IO ()
casADi__Matrix_int___clear
  :: IMatrix -> IO ()
casADi__Matrix_int___clear x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_int___clear x0' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL] 
-}
imatrix_clear :: IMatrixClass a => a -> IO ()
imatrix_clear x = casADi__Matrix_int___clear (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___resize" c_CasADi__Matrix_int___resize
  :: Ptr IMatrix' -> CInt -> CInt -> IO ()
casADi__Matrix_int___resize
  :: IMatrix -> Int -> Int -> IO ()
casADi__Matrix_int___resize x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_int___resize x0' x1' x2' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL] 
-}
imatrix_resize :: IMatrixClass a => a -> Int -> Int -> IO ()
imatrix_resize x = casADi__Matrix_int___resize (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___reserve" c_CasADi__Matrix_int___reserve
  :: Ptr IMatrix' -> CInt -> IO ()
casADi__Matrix_int___reserve
  :: IMatrix -> Int -> IO ()
casADi__Matrix_int___reserve x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_int___reserve x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL] 
-}
imatrix_reserve :: IMatrixClass a => a -> Int -> IO ()
imatrix_reserve x = casADi__Matrix_int___reserve (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___reserve_TIC" c_CasADi__Matrix_int___reserve_TIC
  :: Ptr IMatrix' -> CInt -> CInt -> IO ()
casADi__Matrix_int___reserve'
  :: IMatrix -> Int -> Int -> IO ()
casADi__Matrix_int___reserve' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_int___reserve_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
imatrix_reserve' :: IMatrixClass a => a -> Int -> Int -> IO ()
imatrix_reserve' x = casADi__Matrix_int___reserve' (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___erase" c_CasADi__Matrix_int___erase
  :: Ptr IMatrix' -> Ptr (CppVec CInt) -> Ptr (CppVec CInt) -> IO ()
casADi__Matrix_int___erase
  :: IMatrix -> Vector Int -> Vector Int -> IO ()
casADi__Matrix_int___erase x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_int___erase x0' x1' x2' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Erase a submatrix
>Erase rows and/or columns of a matrix.
-}
imatrix_erase :: IMatrixClass a => a -> Vector Int -> Vector Int -> IO ()
imatrix_erase x = casADi__Matrix_int___erase (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___remove" c_CasADi__Matrix_int___remove
  :: Ptr IMatrix' -> Ptr (CppVec CInt) -> Ptr (CppVec CInt) -> IO ()
casADi__Matrix_int___remove
  :: IMatrix -> Vector Int -> Vector Int -> IO ()
casADi__Matrix_int___remove x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_int___remove x0' x1' x2' >>= wrapReturn

-- classy wrapper
{-|
> [INTERNAL]  Remove cols or
>rows Rremove/delete rows and/or columns of a matrix.
-}
imatrix_remove :: IMatrixClass a => a -> Vector Int -> Vector Int -> IO ()
imatrix_remove x = casADi__Matrix_int___remove (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___enlarge" c_CasADi__Matrix_int___enlarge
  :: Ptr IMatrix' -> CInt -> CInt -> Ptr (CppVec CInt) -> Ptr (CppVec CInt) -> IO ()
casADi__Matrix_int___enlarge
  :: IMatrix -> Int -> Int -> Vector Int -> Vector Int -> IO ()
casADi__Matrix_int___enlarge x0 x1 x2 x3 x4 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  c_CasADi__Matrix_int___enlarge x0' x1' x2' x3' x4' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Enlarge matrix
>Make the matrix larger by inserting empty rows and columns, keeping the
>existing non-zeros.
-}
imatrix_enlarge :: IMatrixClass a => a -> Int -> Int -> Vector Int -> Vector Int -> IO ()
imatrix_enlarge x = casADi__Matrix_int___enlarge (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___data" c_CasADi__Matrix_int___data
  :: Ptr IMatrix' -> IO (Ptr (CppVec CInt))
casADi__Matrix_int___data
  :: IMatrix -> IO (Vector Int)
casADi__Matrix_int___data x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_int___data x0' >>= wrapReturn

-- classy wrapper
{-|
>>  std::vector< DataType > & CasADi::Matrix< DataType >::data()
>------------------------------------------------------------------------
>[INTERNAL] 
>Access the non-zero elements.
>
>>  const std::vector< DataType > & CasADi::Matrix< DataType >::data() const 
>------------------------------------------------------------------------
>[INTERNAL] 
>Const access the non-zero elements.
-}
imatrix_data :: IMatrixClass a => a -> IO (Vector Int)
imatrix_data x = casADi__Matrix_int___data (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___sparsityRef" c_CasADi__Matrix_int___sparsityRef
  :: Ptr IMatrix' -> IO (Ptr Sparsity')
casADi__Matrix_int___sparsityRef
  :: IMatrix -> IO Sparsity
casADi__Matrix_int___sparsityRef x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_int___sparsityRef x0' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Access the
>sparsity, make a copy if there are multiple references to it.
-}
imatrix_sparsityRef :: IMatrixClass a => a -> IO Sparsity
imatrix_sparsityRef x = casADi__Matrix_int___sparsityRef (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___set" c_CasADi__Matrix_int___set
  :: Ptr IMatrix' -> CInt -> CInt -> IO ()
casADi__Matrix_int___set
  :: IMatrix -> Int -> SparsityType -> IO ()
casADi__Matrix_int___set x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_int___set x0' x1' x2' >>= wrapReturn

-- classy wrapper
{-|
>>  void CasADi::Matrix< DataType >::set(DataType val, SparsityType sp=SPARSE)
>------------------------------------------------------------------------
>[INTERNAL] 
>Set the non-zero elements, scalar.
>
>>  void CasADi::Matrix< DataType >::set(const std::vector< DataType > &val, SparsityType sp=SPARSE)
>------------------------------------------------------------------------
>[INTERNAL] 
>Set the non-zero elements, vector.
>
>>  void CasADi::Matrix< DataType >::set(const Matrix< DataType > &val, SparsityType sp=SPARSE)
>------------------------------------------------------------------------
>[INTERNAL] 
>Set the non-zero elements, Matrix.
>
>>  void CasADi::Matrix< DataType >::set(const DataType *val, SparsityType sp=SPARSE)
>------------------------------------------------------------------------
>[INTERNAL] 
>Legacy - use setArray instead.
-}
imatrix_set :: IMatrixClass a => a -> Int -> SparsityType -> IO ()
imatrix_set x = casADi__Matrix_int___set (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___set_TIC" c_CasADi__Matrix_int___set_TIC
  :: Ptr IMatrix' -> CInt -> IO ()
casADi__Matrix_int___set'
  :: IMatrix -> Int -> IO ()
casADi__Matrix_int___set' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_int___set_TIC x0' x1' >>= wrapReturn

-- classy wrapper
imatrix_set' :: IMatrixClass a => a -> Int -> IO ()
imatrix_set' x = casADi__Matrix_int___set' (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___get" c_CasADi__Matrix_int___get
  :: Ptr IMatrix' -> CInt -> CInt -> IO ()
casADi__Matrix_int___get
  :: IMatrix -> Int -> SparsityType -> IO ()
casADi__Matrix_int___get x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_int___get x0' x1' x2' >>= wrapReturn

-- classy wrapper
{-|
>>  void CasADi::Matrix< DataType >::get(DataType &val, SparsityType sp=SPARSE) const 
>------------------------------------------------------------------------
>[INTERNAL] 
>Get the non-zero elements, scalar.
>
>>  void CasADi::Matrix< DataType >::get(std::vector< DataType > &val, SparsityType sp=SPARSE) const 
>------------------------------------------------------------------------
>[INTERNAL] 
>Get the non-zero elements, vector.
>
>>  void CasADi::Matrix< DataType >::get(Matrix< DataType > &val, SparsityType sp=SPARSE) const 
>------------------------------------------------------------------------
>[INTERNAL] 
>Get the non-zero elements, Matrix.
>
>>  void CasADi::Matrix< DataType >::get(DataType *val, SparsityType sp=SPARSE) const 
>------------------------------------------------------------------------
>[INTERNAL] 
>Legacy - use getArray instead.
-}
imatrix_get :: IMatrixClass a => a -> Int -> SparsityType -> IO ()
imatrix_get x = casADi__Matrix_int___get (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___get_TIC" c_CasADi__Matrix_int___get_TIC
  :: Ptr IMatrix' -> CInt -> IO ()
casADi__Matrix_int___get'
  :: IMatrix -> Int -> IO ()
casADi__Matrix_int___get' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_int___get_TIC x0' x1' >>= wrapReturn

-- classy wrapper
imatrix_get' :: IMatrixClass a => a -> Int -> IO ()
imatrix_get' x = casADi__Matrix_int___get' (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___set_TIC_TIC" c_CasADi__Matrix_int___set_TIC_TIC
  :: Ptr IMatrix' -> Ptr (CppVec CInt) -> CInt -> IO ()
casADi__Matrix_int___set''
  :: IMatrix -> Vector Int -> SparsityType -> IO ()
casADi__Matrix_int___set'' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_int___set_TIC_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
imatrix_set'' :: IMatrixClass a => a -> Vector Int -> SparsityType -> IO ()
imatrix_set'' x = casADi__Matrix_int___set'' (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___set_TIC_TIC_TIC" c_CasADi__Matrix_int___set_TIC_TIC_TIC
  :: Ptr IMatrix' -> Ptr (CppVec CInt) -> IO ()
casADi__Matrix_int___set'''
  :: IMatrix -> Vector Int -> IO ()
casADi__Matrix_int___set''' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_int___set_TIC_TIC_TIC x0' x1' >>= wrapReturn

-- classy wrapper
imatrix_set''' :: IMatrixClass a => a -> Vector Int -> IO ()
imatrix_set''' x = casADi__Matrix_int___set''' (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___get_TIC_TIC" c_CasADi__Matrix_int___get_TIC_TIC
  :: Ptr IMatrix' -> Ptr (CppVec CInt) -> CInt -> IO ()
casADi__Matrix_int___get''
  :: IMatrix -> Vector Int -> SparsityType -> IO ()
casADi__Matrix_int___get'' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_int___get_TIC_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
imatrix_get'' :: IMatrixClass a => a -> Vector Int -> SparsityType -> IO ()
imatrix_get'' x = casADi__Matrix_int___get'' (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___get_TIC_TIC_TIC" c_CasADi__Matrix_int___get_TIC_TIC_TIC
  :: Ptr IMatrix' -> Ptr (CppVec CInt) -> IO ()
casADi__Matrix_int___get'''
  :: IMatrix -> Vector Int -> IO ()
casADi__Matrix_int___get''' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_int___get_TIC_TIC_TIC x0' x1' >>= wrapReturn

-- classy wrapper
imatrix_get''' :: IMatrixClass a => a -> Vector Int -> IO ()
imatrix_get''' x = casADi__Matrix_int___get''' (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___set_TIC_TIC_TIC_TIC" c_CasADi__Matrix_int___set_TIC_TIC_TIC_TIC
  :: Ptr IMatrix' -> Ptr IMatrix' -> CInt -> IO ()
casADi__Matrix_int___set''''
  :: IMatrix -> IMatrix -> SparsityType -> IO ()
casADi__Matrix_int___set'''' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_int___set_TIC_TIC_TIC_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
imatrix_set'''' :: IMatrixClass a => a -> IMatrix -> SparsityType -> IO ()
imatrix_set'''' x = casADi__Matrix_int___set'''' (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___set_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_int___set_TIC_TIC_TIC_TIC_TIC
  :: Ptr IMatrix' -> Ptr IMatrix' -> IO ()
casADi__Matrix_int___set'''''
  :: IMatrix -> IMatrix -> IO ()
casADi__Matrix_int___set''''' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_int___set_TIC_TIC_TIC_TIC_TIC x0' x1' >>= wrapReturn

-- classy wrapper
imatrix_set''''' :: IMatrixClass a => a -> IMatrix -> IO ()
imatrix_set''''' x = casADi__Matrix_int___set''''' (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___get_TIC_TIC_TIC_TIC" c_CasADi__Matrix_int___get_TIC_TIC_TIC_TIC
  :: Ptr IMatrix' -> Ptr IMatrix' -> CInt -> IO ()
casADi__Matrix_int___get''''
  :: IMatrix -> IMatrix -> SparsityType -> IO ()
casADi__Matrix_int___get'''' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_int___get_TIC_TIC_TIC_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
imatrix_get'''' :: IMatrixClass a => a -> IMatrix -> SparsityType -> IO ()
imatrix_get'''' x = casADi__Matrix_int___get'''' (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___get_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_int___get_TIC_TIC_TIC_TIC_TIC
  :: Ptr IMatrix' -> Ptr IMatrix' -> IO ()
casADi__Matrix_int___get'''''
  :: IMatrix -> IMatrix -> IO ()
casADi__Matrix_int___get''''' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_int___get_TIC_TIC_TIC_TIC_TIC x0' x1' >>= wrapReturn

-- classy wrapper
imatrix_get''''' :: IMatrixClass a => a -> IMatrix -> IO ()
imatrix_get''''' x = casADi__Matrix_int___get''''' (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___triplet" c_CasADi__Matrix_int___triplet
  :: Ptr (CppVec CInt) -> Ptr (CppVec CInt) -> Ptr (CppVec CInt) -> IO (Ptr IMatrix')
casADi__Matrix_int___triplet
  :: Vector Int -> Vector Int -> Vector Int -> IO IMatrix
casADi__Matrix_int___triplet x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_int___triplet x0' x1' x2' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL] 
-}
imatrix_triplet :: Vector Int -> Vector Int -> Vector Int -> IO IMatrix
imatrix_triplet = casADi__Matrix_int___triplet


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___triplet_TIC" c_CasADi__Matrix_int___triplet_TIC
  :: Ptr (CppVec CInt) -> Ptr (CppVec CInt) -> Ptr (CppVec CInt) -> CInt -> CInt -> IO (Ptr IMatrix')
casADi__Matrix_int___triplet'
  :: Vector Int -> Vector Int -> Vector Int -> Int -> Int -> IO IMatrix
casADi__Matrix_int___triplet' x0 x1 x2 x3 x4 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  c_CasADi__Matrix_int___triplet_TIC x0' x1' x2' x3' x4' >>= wrapReturn

-- classy wrapper
imatrix_triplet' :: Vector Int -> Vector Int -> Vector Int -> Int -> Int -> IO IMatrix
imatrix_triplet' = casADi__Matrix_int___triplet'


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___inf" c_CasADi__Matrix_int___inf
  :: Ptr Sparsity' -> IO (Ptr IMatrix')
casADi__Matrix_int___inf
  :: Sparsity -> IO IMatrix
casADi__Matrix_int___inf x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_int___inf x0' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  create a matrix with
>all inf
-}
imatrix_inf :: Sparsity -> IO IMatrix
imatrix_inf = casADi__Matrix_int___inf


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___inf_TIC" c_CasADi__Matrix_int___inf_TIC
  :: CInt -> CInt -> IO (Ptr IMatrix')
casADi__Matrix_int___inf'
  :: Int -> Int -> IO IMatrix
casADi__Matrix_int___inf' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_int___inf_TIC x0' x1' >>= wrapReturn

-- classy wrapper
imatrix_inf' :: Int -> Int -> IO IMatrix
imatrix_inf' = casADi__Matrix_int___inf'


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___inf_TIC_TIC" c_CasADi__Matrix_int___inf_TIC_TIC
  :: CInt -> IO (Ptr IMatrix')
casADi__Matrix_int___inf''
  :: Int -> IO IMatrix
casADi__Matrix_int___inf'' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_int___inf_TIC_TIC x0' >>= wrapReturn

-- classy wrapper
imatrix_inf'' :: Int -> IO IMatrix
imatrix_inf'' = casADi__Matrix_int___inf''


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___inf_TIC_TIC_TIC" c_CasADi__Matrix_int___inf_TIC_TIC_TIC
  :: IO (Ptr IMatrix')
casADi__Matrix_int___inf'''
  :: IO IMatrix
casADi__Matrix_int___inf'''  =
  c_CasADi__Matrix_int___inf_TIC_TIC_TIC  >>= wrapReturn

-- classy wrapper
imatrix_inf''' :: IO IMatrix
imatrix_inf''' = casADi__Matrix_int___inf'''


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___nan" c_CasADi__Matrix_int___nan
  :: Ptr Sparsity' -> IO (Ptr IMatrix')
casADi__Matrix_int___nan
  :: Sparsity -> IO IMatrix
casADi__Matrix_int___nan x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_int___nan x0' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  create a matrix with
>all nan
-}
imatrix_nan :: Sparsity -> IO IMatrix
imatrix_nan = casADi__Matrix_int___nan


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___nan_TIC" c_CasADi__Matrix_int___nan_TIC
  :: CInt -> CInt -> IO (Ptr IMatrix')
casADi__Matrix_int___nan'
  :: Int -> Int -> IO IMatrix
casADi__Matrix_int___nan' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_int___nan_TIC x0' x1' >>= wrapReturn

-- classy wrapper
imatrix_nan' :: Int -> Int -> IO IMatrix
imatrix_nan' = casADi__Matrix_int___nan'


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___nan_TIC_TIC" c_CasADi__Matrix_int___nan_TIC_TIC
  :: CInt -> IO (Ptr IMatrix')
casADi__Matrix_int___nan''
  :: Int -> IO IMatrix
casADi__Matrix_int___nan'' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_int___nan_TIC_TIC x0' >>= wrapReturn

-- classy wrapper
imatrix_nan'' :: Int -> IO IMatrix
imatrix_nan'' = casADi__Matrix_int___nan''


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___nan_TIC_TIC_TIC" c_CasADi__Matrix_int___nan_TIC_TIC_TIC
  :: IO (Ptr IMatrix')
casADi__Matrix_int___nan'''
  :: IO IMatrix
casADi__Matrix_int___nan'''  =
  c_CasADi__Matrix_int___nan_TIC_TIC_TIC  >>= wrapReturn

-- classy wrapper
imatrix_nan''' :: IO IMatrix
imatrix_nan''' = casADi__Matrix_int___nan'''


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___repmat" c_CasADi__Matrix_int___repmat
  :: CInt -> Ptr Sparsity' -> IO (Ptr IMatrix')
casADi__Matrix_int___repmat
  :: Int -> Sparsity -> IO IMatrix
casADi__Matrix_int___repmat x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_int___repmat x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  create a matrix
>by repeating an existing matrix
-}
imatrix_repmat :: Int -> Sparsity -> IO IMatrix
imatrix_repmat = casADi__Matrix_int___repmat


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___repmat_TIC" c_CasADi__Matrix_int___repmat_TIC
  :: Ptr IMatrix' -> Ptr Sparsity' -> IO (Ptr IMatrix')
casADi__Matrix_int___repmat'
  :: IMatrix -> Sparsity -> IO IMatrix
casADi__Matrix_int___repmat' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_int___repmat_TIC x0' x1' >>= wrapReturn

-- classy wrapper
imatrix_repmat' :: IMatrix -> Sparsity -> IO IMatrix
imatrix_repmat' = casADi__Matrix_int___repmat'


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___repmat_TIC_TIC" c_CasADi__Matrix_int___repmat_TIC_TIC
  :: Ptr IMatrix' -> CInt -> CInt -> IO (Ptr IMatrix')
casADi__Matrix_int___repmat''
  :: IMatrix -> Int -> Int -> IO IMatrix
casADi__Matrix_int___repmat'' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_int___repmat_TIC_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
imatrix_repmat'' :: IMatrix -> Int -> Int -> IO IMatrix
imatrix_repmat'' = casADi__Matrix_int___repmat''


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___repmat_TIC_TIC_TIC" c_CasADi__Matrix_int___repmat_TIC_TIC_TIC
  :: Ptr IMatrix' -> CInt -> IO (Ptr IMatrix')
casADi__Matrix_int___repmat'''
  :: IMatrix -> Int -> IO IMatrix
casADi__Matrix_int___repmat''' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_int___repmat_TIC_TIC_TIC x0' x1' >>= wrapReturn

-- classy wrapper
imatrix_repmat''' :: IMatrix -> Int -> IO IMatrix
imatrix_repmat''' = casADi__Matrix_int___repmat'''


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___eye" c_CasADi__Matrix_int___eye
  :: CInt -> IO (Ptr IMatrix')
casADi__Matrix_int___eye
  :: Int -> IO IMatrix
casADi__Matrix_int___eye x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_int___eye x0' >>= wrapReturn

-- classy wrapper
imatrix_eye :: Int -> IO IMatrix
imatrix_eye = casADi__Matrix_int___eye


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___isRegular" c_CasADi__Matrix_int___isRegular
  :: Ptr IMatrix' -> IO CInt
casADi__Matrix_int___isRegular
  :: IMatrix -> IO Bool
casADi__Matrix_int___isRegular x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_int___isRegular x0' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Checks if
>expression does not contain NaN or Inf.
-}
imatrix_isRegular :: IMatrixClass a => a -> IO Bool
imatrix_isRegular x = casADi__Matrix_int___isRegular (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___isSmooth" c_CasADi__Matrix_int___isSmooth
  :: Ptr IMatrix' -> IO CInt
casADi__Matrix_int___isSmooth
  :: IMatrix -> IO Bool
casADi__Matrix_int___isSmooth x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_int___isSmooth x0' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Check if
>smooth.
-}
imatrix_isSmooth :: IMatrixClass a => a -> IO Bool
imatrix_isSmooth x = casADi__Matrix_int___isSmooth (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___isSymbolic" c_CasADi__Matrix_int___isSymbolic
  :: Ptr IMatrix' -> IO CInt
casADi__Matrix_int___isSymbolic
  :: IMatrix -> IO Bool
casADi__Matrix_int___isSymbolic x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_int___isSymbolic x0' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Check if
>symbolic (Dense) Sparse matrices invariable return false.
-}
imatrix_isSymbolic :: IMatrixClass a => a -> IO Bool
imatrix_isSymbolic x = casADi__Matrix_int___isSymbolic (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___isSymbolicSparse" c_CasADi__Matrix_int___isSymbolicSparse
  :: Ptr IMatrix' -> IO CInt
casADi__Matrix_int___isSymbolicSparse
  :: IMatrix -> IO Bool
casADi__Matrix_int___isSymbolicSparse x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_int___isSymbolicSparse x0' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Check
>if symbolic Sparse matrices can return true if all non-zero elements are
>symbolic.
-}
imatrix_isSymbolicSparse :: IMatrixClass a => a -> IO Bool
imatrix_isSymbolicSparse x = casADi__Matrix_int___isSymbolicSparse (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___isConstant" c_CasADi__Matrix_int___isConstant
  :: Ptr IMatrix' -> IO CInt
casADi__Matrix_int___isConstant
  :: IMatrix -> IO Bool
casADi__Matrix_int___isConstant x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_int___isConstant x0' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Check if the
>matrix is constant (note that false negative answers are possible)
-}
imatrix_isConstant :: IMatrixClass a => a -> IO Bool
imatrix_isConstant x = casADi__Matrix_int___isConstant (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___isInteger" c_CasADi__Matrix_int___isInteger
  :: Ptr IMatrix' -> IO CInt
casADi__Matrix_int___isInteger
  :: IMatrix -> IO Bool
casADi__Matrix_int___isInteger x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_int___isInteger x0' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Check if the
>matrix is integer-valued (note that false negative answers are possible)
-}
imatrix_isInteger :: IMatrixClass a => a -> IO Bool
imatrix_isInteger x = casADi__Matrix_int___isInteger (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___isZero" c_CasADi__Matrix_int___isZero
  :: Ptr IMatrix' -> IO CInt
casADi__Matrix_int___isZero
  :: IMatrix -> IO Bool
casADi__Matrix_int___isZero x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_int___isZero x0' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  check if the
>matrix is 0 (note that false negative answers are possible)
-}
imatrix_isZero :: IMatrixClass a => a -> IO Bool
imatrix_isZero x = casADi__Matrix_int___isZero (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___isOne" c_CasADi__Matrix_int___isOne
  :: Ptr IMatrix' -> IO CInt
casADi__Matrix_int___isOne
  :: IMatrix -> IO Bool
casADi__Matrix_int___isOne x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_int___isOne x0' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  check if the
>matrix is 1 (note that false negative answers are possible)
-}
imatrix_isOne :: IMatrixClass a => a -> IO Bool
imatrix_isOne x = casADi__Matrix_int___isOne (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___isMinusOne" c_CasADi__Matrix_int___isMinusOne
  :: Ptr IMatrix' -> IO CInt
casADi__Matrix_int___isMinusOne
  :: IMatrix -> IO Bool
casADi__Matrix_int___isMinusOne x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_int___isMinusOne x0' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  check if the
>matrix is -1 (note that false negative answers are possible)
-}
imatrix_isMinusOne :: IMatrixClass a => a -> IO Bool
imatrix_isMinusOne x = casADi__Matrix_int___isMinusOne (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___isIdentity" c_CasADi__Matrix_int___isIdentity
  :: Ptr IMatrix' -> IO CInt
casADi__Matrix_int___isIdentity
  :: IMatrix -> IO Bool
casADi__Matrix_int___isIdentity x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_int___isIdentity x0' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  check if the
>matrix is an identity matrix (note that false negative answers are possible)
-}
imatrix_isIdentity :: IMatrixClass a => a -> IO Bool
imatrix_isIdentity x = casADi__Matrix_int___isIdentity (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___isEqual" c_CasADi__Matrix_int___isEqual
  :: Ptr IMatrix' -> Ptr IMatrix' -> IO CInt
casADi__Matrix_int___isEqual
  :: IMatrix -> IMatrix -> IO Bool
casADi__Matrix_int___isEqual x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_int___isEqual x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Check if two
>expressions are equal May give false negatives.
>
>Note: does not work when CasadiOptions.setSimplificationOnTheFly(False) was
>called
-}
imatrix_isEqual :: IMatrixClass a => a -> IMatrix -> IO Bool
imatrix_isEqual x = casADi__Matrix_int___isEqual (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___hasNonStructuralZeros" c_CasADi__Matrix_int___hasNonStructuralZeros
  :: Ptr IMatrix' -> IO CInt
casADi__Matrix_int___hasNonStructuralZeros
  :: IMatrix -> IO Bool
casADi__Matrix_int___hasNonStructuralZeros x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_int___hasNonStructuralZeros x0' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]
>Check if the matrix has any zero entries which are not structural zeros.
-}
imatrix_hasNonStructuralZeros :: IMatrixClass a => a -> IO Bool
imatrix_hasNonStructuralZeros x = casADi__Matrix_int___hasNonStructuralZeros (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___getValue" c_CasADi__Matrix_int___getValue
  :: Ptr IMatrix' -> IO CDouble
casADi__Matrix_int___getValue
  :: IMatrix -> IO Double
casADi__Matrix_int___getValue x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_int___getValue x0' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Get double
>value (only if constant)
-}
imatrix_getValue :: IMatrixClass a => a -> IO Double
imatrix_getValue x = casADi__Matrix_int___getValue (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___getName" c_CasADi__Matrix_int___getName
  :: Ptr IMatrix' -> IO (Ptr StdString')
casADi__Matrix_int___getName
  :: IMatrix -> IO String
casADi__Matrix_int___getName x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_int___getName x0' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Get name (only
>if symbolic scalar)
-}
imatrix_getName :: IMatrixClass a => a -> IO String
imatrix_getName x = casADi__Matrix_int___getName (castIMatrix x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___setPrecision" c_CasADi__Matrix_int___setPrecision
  :: CInt -> IO ()
casADi__Matrix_int___setPrecision
  :: Int -> IO ()
casADi__Matrix_int___setPrecision x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_int___setPrecision x0' >>= wrapReturn

-- classy wrapper
{-|
>Set the 'precision, width & scientific' used in printing and serializing to
>streams.
-}
imatrix_setPrecision :: Int -> IO ()
imatrix_setPrecision = casADi__Matrix_int___setPrecision


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___setWidth" c_CasADi__Matrix_int___setWidth
  :: CInt -> IO ()
casADi__Matrix_int___setWidth
  :: Int -> IO ()
casADi__Matrix_int___setWidth x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_int___setWidth x0' >>= wrapReturn

-- classy wrapper
{-|
>Set the 'precision, width & scientific' used in printing and serializing to
>streams.
-}
imatrix_setWidth :: Int -> IO ()
imatrix_setWidth = casADi__Matrix_int___setWidth


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___setScientific" c_CasADi__Matrix_int___setScientific
  :: CInt -> IO ()
casADi__Matrix_int___setScientific
  :: Bool -> IO ()
casADi__Matrix_int___setScientific x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_int___setScientific x0' >>= wrapReturn

-- classy wrapper
{-|
>Set the 'precision, width & scientific' used in printing and serializing to
>streams.
-}
imatrix_setScientific :: Bool -> IO ()
imatrix_setScientific = casADi__Matrix_int___setScientific


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___IMatrix" c_CasADi__Matrix_int___IMatrix
  :: IO (Ptr IMatrix')
casADi__Matrix_int___IMatrix
  :: IO IMatrix
casADi__Matrix_int___IMatrix  =
  c_CasADi__Matrix_int___IMatrix  >>= wrapReturn

-- classy wrapper
{-|
>>  CasADi::Matrix< DataType >::Matrix(int nrow, int ncol)
>
>>  CasADi::Matrix< DataType >::Matrix(int nrow, int ncol, const DataType &val)
>
>>  CasADi::Matrix< DataType >::Matrix(int nrow, int ncol, const std::vector< int > &colind, const std::vector< int > &row, const std::vector< DataType > &d=std::vector< DataType >())
>------------------------------------------------------------------------
>
>[DEPRECATED]
>
>>  CasADi::Matrix< DataType >::Matrix(const Sparsity &sparsity, const DataType &val=DataType(0))
>------------------------------------------------------------------------
>[INTERNAL] 
>Sparse matrix with a given sparsity.
>
>>  CasADi::Matrix< DataType >::Matrix()
>------------------------------------------------------------------------
>[INTERNAL] 
>constructors
>
>empty 0-by-0 matrix constructor
>
>>  CasADi::Matrix< DataType >::Matrix(const Matrix< DataType > &m)
>------------------------------------------------------------------------
>[INTERNAL] 
>Copy constructor.
>
>>  CasADi::Matrix< DataType >::Matrix(const std::vector< std::vector< DataType > > &m)
>------------------------------------------------------------------------
>[INTERNAL] 
>Dense matrix constructor with data given as vector of vectors.
>
>>  CasADi::Matrix< DataType >::Matrix(const Sparsity &sparsity, const std::vector< DataType > &d)
>------------------------------------------------------------------------
>[INTERNAL] 
>Sparse matrix with a given sparsity and non-zero elements.
>
>>  CasADi::Matrix< DataType >::Matrix(double val)
>------------------------------------------------------------------------
>[INTERNAL] 
>This constructor enables implicit type conversion from a numeric type.
>
>>  CasADi::Matrix< DataType >::Matrix(const std::vector< DataType > &x)
>------------------------------------------------------------------------
>[INTERNAL] 
>Construct from a vector.
>
>Thanks to implicit conversion, you can pretend that Matrix(const SXElement&
>x); exists. Note: above remark applies only to C++, not python or octave
>interfaces
>
>>  CasADi::Matrix< DataType >::Matrix(const std::vector< DataType > &x, int nrow, int ncol)
>------------------------------------------------------------------------
>[INTERNAL] 
>Construct dense matrix from a vector with the elements in column major
>ordering.
>
>>  CasADi::Matrix< T >::Matrix(const Matrix< A > &x)
>------------------------------------------------------------------------
>
>Create a matrix from a matrix with a different type of matrix entries
>(assuming that the scalar conversion is valid)
>
>>  CasADi::Matrix< T >::Matrix(const std::vector< A > &x)
>------------------------------------------------------------------------
>
>Create an expression from an stl vector.
>
>>  CasADi::Matrix< T >::Matrix(const std::vector< A > &x, int nrow, int ncol)
>------------------------------------------------------------------------
>
>Create a non-vector expression from an stl vector.
-}
imatrix :: IO IMatrix
imatrix = casADi__Matrix_int___IMatrix


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___IMatrix_TIC" c_CasADi__Matrix_int___IMatrix_TIC
  :: Ptr IMatrix' -> IO (Ptr IMatrix')
casADi__Matrix_int___IMatrix'
  :: IMatrix -> IO IMatrix
casADi__Matrix_int___IMatrix' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_int___IMatrix_TIC x0' >>= wrapReturn

-- classy wrapper
imatrix' :: IMatrix -> IO IMatrix
imatrix' = casADi__Matrix_int___IMatrix'


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___IMatrix_TIC_TIC" c_CasADi__Matrix_int___IMatrix_TIC_TIC
  :: Ptr (CppVec (Ptr (CppVec CInt))) -> IO (Ptr IMatrix')
casADi__Matrix_int___IMatrix''
  :: Vector (Vector Int) -> IO IMatrix
casADi__Matrix_int___IMatrix'' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_int___IMatrix_TIC_TIC x0' >>= wrapReturn

-- classy wrapper
imatrix'' :: Vector (Vector Int) -> IO IMatrix
imatrix'' = casADi__Matrix_int___IMatrix''


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___IMatrix_TIC_TIC_TIC" c_CasADi__Matrix_int___IMatrix_TIC_TIC_TIC
  :: Ptr Sparsity' -> CInt -> IO (Ptr IMatrix')
casADi__Matrix_int___IMatrix'''
  :: Sparsity -> Int -> IO IMatrix
casADi__Matrix_int___IMatrix''' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_int___IMatrix_TIC_TIC_TIC x0' x1' >>= wrapReturn

-- classy wrapper
imatrix''' :: Sparsity -> Int -> IO IMatrix
imatrix''' = casADi__Matrix_int___IMatrix'''


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___IMatrix_TIC_TIC_TIC_TIC" c_CasADi__Matrix_int___IMatrix_TIC_TIC_TIC_TIC
  :: Ptr Sparsity' -> IO (Ptr IMatrix')
casADi__Matrix_int___IMatrix''''
  :: Sparsity -> IO IMatrix
casADi__Matrix_int___IMatrix'''' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_int___IMatrix_TIC_TIC_TIC_TIC x0' >>= wrapReturn

-- classy wrapper
imatrix'''' :: Sparsity -> IO IMatrix
imatrix'''' = casADi__Matrix_int___IMatrix''''


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___IMatrix_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_int___IMatrix_TIC_TIC_TIC_TIC_TIC
  :: Ptr Sparsity' -> Ptr (CppVec CInt) -> IO (Ptr IMatrix')
casADi__Matrix_int___IMatrix'''''
  :: Sparsity -> Vector Int -> IO IMatrix
casADi__Matrix_int___IMatrix''''' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_int___IMatrix_TIC_TIC_TIC_TIC_TIC x0' x1' >>= wrapReturn

-- classy wrapper
imatrix''''' :: Sparsity -> Vector Int -> IO IMatrix
imatrix''''' = casADi__Matrix_int___IMatrix'''''


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___IMatrix_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_int___IMatrix_TIC_TIC_TIC_TIC_TIC_TIC
  :: CDouble -> IO (Ptr IMatrix')
casADi__Matrix_int___IMatrix''''''
  :: Double -> IO IMatrix
casADi__Matrix_int___IMatrix'''''' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_int___IMatrix_TIC_TIC_TIC_TIC_TIC_TIC x0' >>= wrapReturn

-- classy wrapper
imatrix'''''' :: Double -> IO IMatrix
imatrix'''''' = casADi__Matrix_int___IMatrix''''''


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___IMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_int___IMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC
  :: Ptr (CppVec CInt) -> IO (Ptr IMatrix')
casADi__Matrix_int___IMatrix'''''''
  :: Vector Int -> IO IMatrix
casADi__Matrix_int___IMatrix''''''' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_int___IMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' >>= wrapReturn

-- classy wrapper
imatrix''''''' :: Vector Int -> IO IMatrix
imatrix''''''' = casADi__Matrix_int___IMatrix'''''''


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_int___IMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_int___IMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC
  :: Ptr (CppVec CInt) -> CInt -> CInt -> IO (Ptr IMatrix')
casADi__Matrix_int___IMatrix''''''''
  :: Vector Int -> Int -> Int -> IO IMatrix
casADi__Matrix_int___IMatrix'''''''' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_int___IMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
imatrix'''''''' :: Vector Int -> Int -> Int -> IO IMatrix
imatrix'''''''' = casADi__Matrix_int___IMatrix''''''''