casadi-bindings-1.9.0.0: Casadi/Wrappers/Classes/SX.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.SX
       (
         SX,
         SXClass(..),
         sx,
         sx',
         sx'',
         sx''',
         sx'''',
         sx''''',
         sx'''''',
         sx''''''',
         sx'''''''',
         sx''''''''',
         sx'''''''''',
         sx''''''''''',
         sx'''''''''''',
         sx''''''''''''',
         sx'''''''''''''',
         sx___add__,
         sx___constpow__,
         sx___copysign__,
         sx___div__,
         sx___eq__,
         sx___le__,
         sx___lt__,
         sx___mpower__,
         sx___mrdivide__,
         sx___mul__,
         sx___ne__,
         sx___nonzero__,
         sx___pow__,
         sx___sub__,
         sx___truediv__,
         sx_append,
         sx_appendColumns,
         sx_arccos,
         sx_arccosh,
         sx_arcsin,
         sx_arcsinh,
         sx_arctan,
         sx_arctan2,
         sx_arctanh,
         sx_at,
         sx_binary,
         sx_ceil,
         sx_className,
         sx_clear,
         sx_colind,
         sx_cos,
         sx_cosh,
         sx_data,
         sx_densify,
         sx_densify',
         sx_elem,
         sx_elem',
         sx_enlarge,
         sx_erase,
         sx_erf,
         sx_erfinv,
         sx_exp,
         sx_eye,
         sx_fabs,
         sx_floor,
         sx_fmax,
         sx_fmin,
         sx_get,
         sx_get',
         sx_get'',
         sx_get''',
         sx_get'''',
         sx_get''''',
         sx_getEqualityCheckingDepth,
         sx_getMaxNumCallsInPrint,
         sx_getName,
         sx_getValue,
         sx_hasNZ,
         sx_hasNonStructuralZeros,
         sx_if_else_zero,
         sx_indexed_assignment,
         sx_indexed_assignment',
         sx_indexed_assignment'',
         sx_indexed_assignment''',
         sx_indexed_assignment'''',
         sx_indexed_assignment''''',
         sx_indexed_assignment'''''',
         sx_indexed_assignment''''''',
         sx_indexed_assignment'''''''',
         sx_indexed_assignment''''''''',
         sx_indexed_one_based_assignment,
         sx_indexed_one_based_assignment',
         sx_indexed_one_based_assignment'',
         sx_indexed_zero_based_assignment,
         sx_indexed_zero_based_assignment',
         sx_indexed_zero_based_assignment'',
         sx_inf,
         sx_inf',
         sx_inf'',
         sx_inf''',
         sx_isConstant,
         sx_isEqual,
         sx_isIdentity,
         sx_isInteger,
         sx_isMinusOne,
         sx_isOne,
         sx_isRegular,
         sx_isSmooth,
         sx_isSymbolic,
         sx_isSymbolicSparse,
         sx_isZero,
         sx_log,
         sx_log10,
         sx_logic_and,
         sx_logic_not,
         sx_logic_or,
         sx_matrix_matrix,
         sx_matrix_scalar,
         sx_mul,
         sx_mul',
         sx_mul_full,
         sx_mul_full',
         sx_mul_no_alloc_nn,
         sx_mul_no_alloc_nn',
         sx_mul_no_alloc_nt,
         sx_mul_no_alloc_tn,
         sx_mul_no_alloc_tn',
         sx_nan,
         sx_nan',
         sx_nan'',
         sx_nan''',
         sx_nz_indexed_assignment,
         sx_nz_indexed_assignment',
         sx_nz_indexed_one_based_assignment,
         sx_nz_indexed_one_based_assignment',
         sx_nz_indexed_zero_based_assignment,
         sx_nz_indexed_zero_based_assignment',
         sx_operator_minus,
         sx_operator_plus,
         sx_printDense',
         sx_printScalar',
         sx_printSparse',
         sx_printVector',
         sx_printme,
         sx_quad_form,
         sx_remove,
         sx_repmat,
         sx_repmat',
         sx_repmat'',
         sx_repmat''',
         sx_reserve,
         sx_reserve',
         sx_resize,
         sx_row,
         sx_sanityCheck,
         sx_sanityCheck',
         sx_scalar_matrix,
         sx_set,
         sx_set',
         sx_set'',
         sx_set''',
         sx_set'''',
         sx_set''''',
         sx_setAll,
         sx_setEqualityCheckingDepth,
         sx_setEqualityCheckingDepth',
         sx_setMaxNumCallsInPrint,
         sx_setMaxNumCallsInPrint',
         sx_setNZ,
         sx_setNZ',
         sx_setNZ'',
         sx_setNZ''',
         sx_setPrecision,
         sx_setScientific,
         sx_setSparse,
         sx_setSparse',
         sx_setSub,
         sx_setSub',
         sx_setSub'',
         sx_setSub''',
         sx_setSub'''',
         sx_setSub''''',
         sx_setSub'''''',
         sx_setSub''''''',
         sx_setSub'''''''',
         sx_setSub''''''''',
         sx_setSub'''''''''',
         sx_setSub''''''''''',
         sx_setSub'''''''''''',
         sx_setSub''''''''''''',
         sx_setWidth,
         sx_setZero,
         sx_sign,
         sx_sin,
         sx_sinh,
         sx_sparsify,
         sx_sparsify',
         sx_sparsityRef,
         sx_sqrt,
         sx_tan,
         sx_tanh,
         sx_trans,
         sx_triplet,
         sx_triplet',
         sx_unary,
       ) where


import Prelude hiding ( Functor )

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

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

instance Show SX where
  show = unsafePerformIO . printableObject_getDescription
-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___sanityCheck" c_CasADi__Matrix_CasADi__SXElement___sanityCheck
  :: Ptr SX' -> CInt -> IO ()
casADi__Matrix_CasADi__SXElement___sanityCheck
  :: SX -> Bool -> IO ()
casADi__Matrix_CasADi__SXElement___sanityCheck x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_CasADi__SXElement___sanityCheck x0' x1' >>= wrapReturn

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


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___sanityCheck_TIC" c_CasADi__Matrix_CasADi__SXElement___sanityCheck_TIC
  :: Ptr SX' -> IO ()
casADi__Matrix_CasADi__SXElement___sanityCheck'
  :: SX -> IO ()
casADi__Matrix_CasADi__SXElement___sanityCheck' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SXElement___sanityCheck_TIC x0' >>= wrapReturn

-- classy wrapper
sx_sanityCheck' :: SXClass a => a -> IO ()
sx_sanityCheck' x = casADi__Matrix_CasADi__SXElement___sanityCheck' (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___at" c_CasADi__Matrix_CasADi__SXElement___at
  :: Ptr SX' -> CInt -> IO (Ptr SXElement')
casADi__Matrix_CasADi__SXElement___at
  :: SX -> Int -> IO SXElement
casADi__Matrix_CasADi__SXElement___at x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_CasADi__SXElement___at x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>>  const DataType& CasADi::Matrix< T >::at(int k) const 
>------------------------------------------------------------------------
>[INTERNAL] 
>Get a non-zero element.
>
>>  DataType& CasADi::Matrix< T >::at(int k)
>------------------------------------------------------------------------
>[INTERNAL] 
>Access a non-zero element.
-}
sx_at :: SXClass a => a -> Int -> IO SXElement
sx_at x = casADi__Matrix_CasADi__SXElement___at (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___elem" c_CasADi__Matrix_CasADi__SXElement___elem
  :: Ptr SX' -> CInt -> CInt -> IO (Ptr SXElement')
casADi__Matrix_CasADi__SXElement___elem
  :: SX -> Int -> Int -> IO SXElement
casADi__Matrix_CasADi__SXElement___elem x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_CasADi__SXElement___elem x0' x1' x2' >>= wrapReturn

-- classy wrapper
{-|
>>  const DataType & CasADi::Matrix< DataType >::elem(int rr, int cc=0) const 
>------------------------------------------------------------------------
>[INTERNAL] 
>get an element
>
>>  DataType & CasADi::Matrix< DataType >::elem(int rr, int cc=0)
>------------------------------------------------------------------------
>[INTERNAL] 
>get a reference to an element
-}
sx_elem :: SXClass a => a -> Int -> Int -> IO SXElement
sx_elem x = casADi__Matrix_CasADi__SXElement___elem (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___elem_TIC" c_CasADi__Matrix_CasADi__SXElement___elem_TIC
  :: Ptr SX' -> CInt -> IO (Ptr SXElement')
casADi__Matrix_CasADi__SXElement___elem'
  :: SX -> Int -> IO SXElement
casADi__Matrix_CasADi__SXElement___elem' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_CasADi__SXElement___elem_TIC x0' x1' >>= wrapReturn

-- classy wrapper
sx_elem' :: SXClass a => a -> Int -> IO SXElement
sx_elem' x = casADi__Matrix_CasADi__SXElement___elem' (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___hasNZ" c_CasADi__Matrix_CasADi__SXElement___hasNZ
  :: Ptr SX' -> CInt -> CInt -> IO CInt
casADi__Matrix_CasADi__SXElement___hasNZ
  :: SX -> Int -> Int -> IO Bool
casADi__Matrix_CasADi__SXElement___hasNZ x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_CasADi__SXElement___hasNZ x0' x1' x2' >>= wrapReturn

-- classy wrapper
{-|
>Returns true if the matrix has a non-zero at location rr,cc.
-}
sx_hasNZ :: SXClass a => a -> Int -> Int -> IO Bool
sx_hasNZ x = casADi__Matrix_CasADi__SXElement___hasNZ (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement_____nonzero__" c_CasADi__Matrix_CasADi__SXElement_____nonzero__
  :: Ptr SX' -> IO CInt
casADi__Matrix_CasADi__SXElement_____nonzero__
  :: SX -> IO Bool
casADi__Matrix_CasADi__SXElement_____nonzero__ x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SXElement_____nonzero__ x0' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Returns the
>truth value of a Matrix.
-}
sx___nonzero__ :: SXClass a => a -> IO Bool
sx___nonzero__ x = casADi__Matrix_CasADi__SXElement_____nonzero__ (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___setSub" c_CasADi__Matrix_CasADi__SXElement___setSub
  :: Ptr SX' -> Ptr SX' -> CInt -> CInt -> IO ()
casADi__Matrix_CasADi__SXElement___setSub
  :: SX -> SX -> Int -> Int -> IO ()
casADi__Matrix_CasADi__SXElement___setSub x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  c_CasADi__Matrix_CasADi__SXElement___setSub x0' x1' x2' x3' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Set a submatrix.
-}
sx_setSub :: SXClass a => a -> SX -> Int -> Int -> IO ()
sx_setSub x = casADi__Matrix_CasADi__SXElement___setSub (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___setSub_TIC" c_CasADi__Matrix_CasADi__SXElement___setSub_TIC
  :: Ptr SX' -> Ptr SX' -> Ptr (CppVec CInt) -> CInt -> IO ()
casADi__Matrix_CasADi__SXElement___setSub'
  :: SX -> SX -> Vector Int -> Int -> IO ()
casADi__Matrix_CasADi__SXElement___setSub' x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  c_CasADi__Matrix_CasADi__SXElement___setSub_TIC x0' x1' x2' x3' >>= wrapReturn

-- classy wrapper
sx_setSub' :: SXClass a => a -> SX -> Vector Int -> Int -> IO ()
sx_setSub' x = casADi__Matrix_CasADi__SXElement___setSub' (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC" c_CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC
  :: Ptr SX' -> Ptr SX' -> CInt -> Ptr (CppVec CInt) -> IO ()
casADi__Matrix_CasADi__SXElement___setSub''
  :: SX -> SX -> Int -> Vector Int -> IO ()
casADi__Matrix_CasADi__SXElement___setSub'' x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  c_CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC x0' x1' x2' x3' >>= wrapReturn

-- classy wrapper
sx_setSub'' :: SXClass a => a -> SX -> Int -> Vector Int -> IO ()
sx_setSub'' x = casADi__Matrix_CasADi__SXElement___setSub'' (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC_TIC
  :: Ptr SX' -> Ptr SX' -> Ptr (CppVec CInt) -> Ptr (CppVec CInt) -> IO ()
casADi__Matrix_CasADi__SXElement___setSub'''
  :: SX -> SX -> Vector Int -> Vector Int -> IO ()
casADi__Matrix_CasADi__SXElement___setSub''' x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  c_CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn

-- classy wrapper
sx_setSub''' :: SXClass a => a -> SX -> Vector Int -> Vector Int -> IO ()
sx_setSub''' x = casADi__Matrix_CasADi__SXElement___setSub''' (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC_TIC_TIC
  :: Ptr SX' -> Ptr SX' -> Ptr Slice' -> Ptr (CppVec CInt) -> IO ()
casADi__Matrix_CasADi__SXElement___setSub''''
  :: SX -> SX -> Slice -> Vector Int -> IO ()
casADi__Matrix_CasADi__SXElement___setSub'''' x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  c_CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn

-- classy wrapper
sx_setSub'''' :: SXClass a => a -> SX -> Slice -> Vector Int -> IO ()
sx_setSub'''' x = casADi__Matrix_CasADi__SXElement___setSub'''' (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC_TIC_TIC_TIC
  :: Ptr SX' -> Ptr SX' -> Ptr (CppVec CInt) -> Ptr Slice' -> IO ()
casADi__Matrix_CasADi__SXElement___setSub'''''
  :: SX -> SX -> Vector Int -> Slice -> IO ()
casADi__Matrix_CasADi__SXElement___setSub''''' x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  c_CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn

-- classy wrapper
sx_setSub''''' :: SXClass a => a -> SX -> Vector Int -> Slice -> IO ()
sx_setSub''''' x = casADi__Matrix_CasADi__SXElement___setSub''''' (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC_TIC_TIC_TIC_TIC
  :: Ptr SX' -> Ptr SX' -> Ptr Slice' -> Ptr Slice' -> IO ()
casADi__Matrix_CasADi__SXElement___setSub''''''
  :: SX -> SX -> Slice -> Slice -> IO ()
casADi__Matrix_CasADi__SXElement___setSub'''''' x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  c_CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn

-- classy wrapper
sx_setSub'''''' :: SXClass a => a -> SX -> Slice -> Slice -> IO ()
sx_setSub'''''' x = casADi__Matrix_CasADi__SXElement___setSub'''''' (castSX x)


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

-- classy wrapper
sx_setSub''''''' :: SXClass a => a -> SX -> IMatrix -> Vector Int -> IO ()
sx_setSub''''''' x = casADi__Matrix_CasADi__SXElement___setSub''''''' (castSX x)


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

-- classy wrapper
sx_setSub'''''''' :: SXClass a => a -> SX -> Vector Int -> IMatrix -> IO ()
sx_setSub'''''''' x = casADi__Matrix_CasADi__SXElement___setSub'''''''' (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC
  :: Ptr SX' -> Ptr SX' -> Ptr IMatrix' -> Ptr Slice' -> IO ()
casADi__Matrix_CasADi__SXElement___setSub'''''''''
  :: SX -> SX -> IMatrix -> Slice -> IO ()
casADi__Matrix_CasADi__SXElement___setSub''''''''' x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  c_CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn

-- classy wrapper
sx_setSub''''''''' :: SXClass a => a -> SX -> IMatrix -> Slice -> IO ()
sx_setSub''''''''' x = casADi__Matrix_CasADi__SXElement___setSub''''''''' (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC
  :: Ptr SX' -> Ptr SX' -> Ptr Slice' -> Ptr IMatrix' -> IO ()
casADi__Matrix_CasADi__SXElement___setSub''''''''''
  :: SX -> SX -> Slice -> IMatrix -> IO ()
casADi__Matrix_CasADi__SXElement___setSub'''''''''' x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  c_CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn

-- classy wrapper
sx_setSub'''''''''' :: SXClass a => a -> SX -> Slice -> IMatrix -> IO ()
sx_setSub'''''''''' x = casADi__Matrix_CasADi__SXElement___setSub'''''''''' (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC
  :: Ptr SX' -> Ptr SX' -> Ptr IMatrix' -> Ptr IMatrix' -> IO ()
casADi__Matrix_CasADi__SXElement___setSub'''''''''''
  :: SX -> SX -> IMatrix -> IMatrix -> IO ()
casADi__Matrix_CasADi__SXElement___setSub''''''''''' x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  c_CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn

-- classy wrapper
sx_setSub''''''''''' :: SXClass a => a -> SX -> IMatrix -> IMatrix -> IO ()
sx_setSub''''''''''' x = casADi__Matrix_CasADi__SXElement___setSub''''''''''' (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC
  :: Ptr SX' -> Ptr SX' -> Ptr Slice' -> CInt -> IO ()
casADi__Matrix_CasADi__SXElement___setSub''''''''''''
  :: SX -> SX -> Slice -> Int -> IO ()
casADi__Matrix_CasADi__SXElement___setSub'''''''''''' x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  c_CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn

-- classy wrapper
sx_setSub'''''''''''' :: SXClass a => a -> SX -> Slice -> Int -> IO ()
sx_setSub'''''''''''' x = casADi__Matrix_CasADi__SXElement___setSub'''''''''''' (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC
  :: Ptr SX' -> Ptr SX' -> Ptr Sparsity' -> CInt -> IO ()
casADi__Matrix_CasADi__SXElement___setSub'''''''''''''
  :: SX -> SX -> Sparsity -> Int -> IO ()
casADi__Matrix_CasADi__SXElement___setSub''''''''''''' x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  c_CasADi__Matrix_CasADi__SXElement___setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn

-- classy wrapper
sx_setSub''''''''''''' :: SXClass a => a -> SX -> Sparsity -> Int -> IO ()
sx_setSub''''''''''''' x = casADi__Matrix_CasADi__SXElement___setSub''''''''''''' (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___setNZ" c_CasADi__Matrix_CasADi__SXElement___setNZ
  :: Ptr SX' -> CInt -> Ptr SX' -> IO ()
casADi__Matrix_CasADi__SXElement___setNZ
  :: SX -> Int -> SX -> IO ()
casADi__Matrix_CasADi__SXElement___setNZ x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_CasADi__SXElement___setNZ x0' x1' x2' >>= wrapReturn

-- classy wrapper
{-|
>>  void CasADi::Matrix< DataType >::setNZ(int k, const Matrix< DataType > &m)
>
>>  void CasADi::Matrix< DataType >::setNZ(const std::vector< int > &k, const Matrix< DataType > &m)
>
>>  void CasADi::Matrix< DataType >::setNZ(const Matrix< int > &k, const Matrix< DataType > &m)
>------------------------------------------------------------------------
>[INTERNAL] 
>Set a set of nonzeros.
>
>>  void CasADi::Matrix< T >::setNZ(const Slice &k, const Matrix< DataType > &m)
>------------------------------------------------------------------------
>
>Set a set of nonzeros.
-}
sx_setNZ :: SXClass a => a -> Int -> SX -> IO ()
sx_setNZ x = casADi__Matrix_CasADi__SXElement___setNZ (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___setNZ_TIC" c_CasADi__Matrix_CasADi__SXElement___setNZ_TIC
  :: Ptr SX' -> Ptr (CppVec CInt) -> Ptr SX' -> IO ()
casADi__Matrix_CasADi__SXElement___setNZ'
  :: SX -> Vector Int -> SX -> IO ()
casADi__Matrix_CasADi__SXElement___setNZ' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_CasADi__SXElement___setNZ_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
sx_setNZ' :: SXClass a => a -> Vector Int -> SX -> IO ()
sx_setNZ' x = casADi__Matrix_CasADi__SXElement___setNZ' (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___setNZ_TIC_TIC" c_CasADi__Matrix_CasADi__SXElement___setNZ_TIC_TIC
  :: Ptr SX' -> Ptr Slice' -> Ptr SX' -> IO ()
casADi__Matrix_CasADi__SXElement___setNZ''
  :: SX -> Slice -> SX -> IO ()
casADi__Matrix_CasADi__SXElement___setNZ'' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_CasADi__SXElement___setNZ_TIC_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
sx_setNZ'' :: SXClass a => a -> Slice -> SX -> IO ()
sx_setNZ'' x = casADi__Matrix_CasADi__SXElement___setNZ'' (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___setNZ_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SXElement___setNZ_TIC_TIC_TIC
  :: Ptr SX' -> Ptr IMatrix' -> Ptr SX' -> IO ()
casADi__Matrix_CasADi__SXElement___setNZ'''
  :: SX -> IMatrix -> SX -> IO ()
casADi__Matrix_CasADi__SXElement___setNZ''' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_CasADi__SXElement___setNZ_TIC_TIC_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
sx_setNZ''' :: SXClass a => a -> IMatrix -> SX -> IO ()
sx_setNZ''' x = casADi__Matrix_CasADi__SXElement___setNZ''' (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___append" c_CasADi__Matrix_CasADi__SXElement___append
  :: Ptr SX' -> Ptr SX' -> IO ()
casADi__Matrix_CasADi__SXElement___append
  :: SX -> SX -> IO ()
casADi__Matrix_CasADi__SXElement___append x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_CasADi__SXElement___append x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Append a matrix
>vertically (NOTE: only efficient if vector)
-}
sx_append :: SXClass a => a -> SX -> IO ()
sx_append x = casADi__Matrix_CasADi__SXElement___append (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___appendColumns" c_CasADi__Matrix_CasADi__SXElement___appendColumns
  :: Ptr SX' -> Ptr SX' -> IO ()
casADi__Matrix_CasADi__SXElement___appendColumns
  :: SX -> SX -> IO ()
casADi__Matrix_CasADi__SXElement___appendColumns x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_CasADi__SXElement___appendColumns x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Append a
>matrix horizontally.
-}
sx_appendColumns :: SXClass a => a -> SX -> IO ()
sx_appendColumns x = casADi__Matrix_CasADi__SXElement___appendColumns (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___nz_indexed_one_based_assignment" c_CasADi__Matrix_CasADi__SXElement___nz_indexed_one_based_assignment
  :: Ptr SX' -> CInt -> Ptr SXElement' -> IO ()
casADi__Matrix_CasADi__SXElement___nz_indexed_one_based_assignment
  :: SX -> Int -> SXElement -> IO ()
casADi__Matrix_CasADi__SXElement___nz_indexed_one_based_assignment x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_CasADi__SXElement___nz_indexed_one_based_assignment x0' x1' x2' >>= wrapReturn

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


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___nz_indexed_zero_based_assignment" c_CasADi__Matrix_CasADi__SXElement___nz_indexed_zero_based_assignment
  :: Ptr SX' -> CInt -> Ptr SXElement' -> IO ()
casADi__Matrix_CasADi__SXElement___nz_indexed_zero_based_assignment
  :: SX -> Int -> SXElement -> IO ()
casADi__Matrix_CasADi__SXElement___nz_indexed_zero_based_assignment x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_CasADi__SXElement___nz_indexed_zero_based_assignment x0' x1' x2' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Indexing for interfaced languages get a non-zero
-}
sx_nz_indexed_zero_based_assignment :: SXClass a => a -> Int -> SXElement -> IO ()
sx_nz_indexed_zero_based_assignment x = casADi__Matrix_CasADi__SXElement___nz_indexed_zero_based_assignment (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___nz_indexed_assignment" c_CasADi__Matrix_CasADi__SXElement___nz_indexed_assignment
  :: Ptr SX' -> Ptr Slice' -> Ptr SX' -> IO ()
casADi__Matrix_CasADi__SXElement___nz_indexed_assignment
  :: SX -> Slice -> SX -> IO ()
casADi__Matrix_CasADi__SXElement___nz_indexed_assignment x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_CasADi__SXElement___nz_indexed_assignment x0' x1' x2' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]
>Indexing for interfaced languages get a non-zero
-}
sx_nz_indexed_assignment :: SXClass a => a -> Slice -> SX -> IO ()
sx_nz_indexed_assignment x = casADi__Matrix_CasADi__SXElement___nz_indexed_assignment (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___indexed_one_based_assignment" c_CasADi__Matrix_CasADi__SXElement___indexed_one_based_assignment
  :: Ptr SX' -> Ptr IMatrix' -> Ptr SX' -> IO ()
casADi__Matrix_CasADi__SXElement___indexed_one_based_assignment
  :: SX -> IMatrix -> SX -> IO ()
casADi__Matrix_CasADi__SXElement___indexed_one_based_assignment x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_CasADi__SXElement___indexed_one_based_assignment x0' x1' x2' >>= wrapReturn

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


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___indexed_zero_based_assignment" c_CasADi__Matrix_CasADi__SXElement___indexed_zero_based_assignment
  :: Ptr SX' -> Ptr IMatrix' -> Ptr SX' -> IO ()
casADi__Matrix_CasADi__SXElement___indexed_zero_based_assignment
  :: SX -> IMatrix -> SX -> IO ()
casADi__Matrix_CasADi__SXElement___indexed_zero_based_assignment x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_CasADi__SXElement___indexed_zero_based_assignment x0' x1' x2' >>= wrapReturn

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


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___nz_indexed_one_based_assignment_TIC" c_CasADi__Matrix_CasADi__SXElement___nz_indexed_one_based_assignment_TIC
  :: Ptr SX' -> Ptr IMatrix' -> Ptr SX' -> IO ()
casADi__Matrix_CasADi__SXElement___nz_indexed_one_based_assignment'
  :: SX -> IMatrix -> SX -> IO ()
casADi__Matrix_CasADi__SXElement___nz_indexed_one_based_assignment' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_CasADi__SXElement___nz_indexed_one_based_assignment_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
sx_nz_indexed_one_based_assignment' :: SXClass a => a -> IMatrix -> SX -> IO ()
sx_nz_indexed_one_based_assignment' x = casADi__Matrix_CasADi__SXElement___nz_indexed_one_based_assignment' (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___nz_indexed_zero_based_assignment_TIC" c_CasADi__Matrix_CasADi__SXElement___nz_indexed_zero_based_assignment_TIC
  :: Ptr SX' -> Ptr IMatrix' -> Ptr SX' -> IO ()
casADi__Matrix_CasADi__SXElement___nz_indexed_zero_based_assignment'
  :: SX -> IMatrix -> SX -> IO ()
casADi__Matrix_CasADi__SXElement___nz_indexed_zero_based_assignment' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_CasADi__SXElement___nz_indexed_zero_based_assignment_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
sx_nz_indexed_zero_based_assignment' :: SXClass a => a -> IMatrix -> SX -> IO ()
sx_nz_indexed_zero_based_assignment' x = casADi__Matrix_CasADi__SXElement___nz_indexed_zero_based_assignment' (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___nz_indexed_assignment_TIC" c_CasADi__Matrix_CasADi__SXElement___nz_indexed_assignment_TIC
  :: Ptr SX' -> Ptr IndexList' -> Ptr SX' -> IO ()
casADi__Matrix_CasADi__SXElement___nz_indexed_assignment'
  :: SX -> IndexList -> SX -> IO ()
casADi__Matrix_CasADi__SXElement___nz_indexed_assignment' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_CasADi__SXElement___nz_indexed_assignment_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
sx_nz_indexed_assignment' :: SXClass a => a -> IndexList -> SX -> IO ()
sx_nz_indexed_assignment' x = casADi__Matrix_CasADi__SXElement___nz_indexed_assignment' (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___indexed_one_based_assignment_TIC" c_CasADi__Matrix_CasADi__SXElement___indexed_one_based_assignment_TIC
  :: Ptr SX' -> CInt -> CInt -> Ptr SXElement' -> IO ()
casADi__Matrix_CasADi__SXElement___indexed_one_based_assignment'
  :: SX -> Int -> Int -> SXElement -> IO ()
casADi__Matrix_CasADi__SXElement___indexed_one_based_assignment' x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  c_CasADi__Matrix_CasADi__SXElement___indexed_one_based_assignment_TIC x0' x1' x2' x3' >>= wrapReturn

-- classy wrapper
sx_indexed_one_based_assignment' :: SXClass a => a -> Int -> Int -> SXElement -> IO ()
sx_indexed_one_based_assignment' x = casADi__Matrix_CasADi__SXElement___indexed_one_based_assignment' (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___indexed_zero_based_assignment_TIC" c_CasADi__Matrix_CasADi__SXElement___indexed_zero_based_assignment_TIC
  :: Ptr SX' -> CInt -> CInt -> Ptr SXElement' -> IO ()
casADi__Matrix_CasADi__SXElement___indexed_zero_based_assignment'
  :: SX -> Int -> Int -> SXElement -> IO ()
casADi__Matrix_CasADi__SXElement___indexed_zero_based_assignment' x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  c_CasADi__Matrix_CasADi__SXElement___indexed_zero_based_assignment_TIC x0' x1' x2' x3' >>= wrapReturn

-- classy wrapper
sx_indexed_zero_based_assignment' :: SXClass a => a -> Int -> Int -> SXElement -> IO ()
sx_indexed_zero_based_assignment' x = casADi__Matrix_CasADi__SXElement___indexed_zero_based_assignment' (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___indexed_assignment" c_CasADi__Matrix_CasADi__SXElement___indexed_assignment
  :: Ptr SX' -> Ptr Slice' -> Ptr Slice' -> Ptr SX' -> IO ()
casADi__Matrix_CasADi__SXElement___indexed_assignment
  :: SX -> Slice -> Slice -> SX -> IO ()
casADi__Matrix_CasADi__SXElement___indexed_assignment x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  c_CasADi__Matrix_CasADi__SXElement___indexed_assignment x0' x1' x2' x3' >>= wrapReturn

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


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___indexed_assignment_TIC" c_CasADi__Matrix_CasADi__SXElement___indexed_assignment_TIC
  :: Ptr SX' -> Ptr IndexList' -> Ptr IndexList' -> Ptr SX' -> IO ()
casADi__Matrix_CasADi__SXElement___indexed_assignment'
  :: SX -> IndexList -> IndexList -> SX -> IO ()
casADi__Matrix_CasADi__SXElement___indexed_assignment' x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  c_CasADi__Matrix_CasADi__SXElement___indexed_assignment_TIC x0' x1' x2' x3' >>= wrapReturn

-- classy wrapper
sx_indexed_assignment' :: SXClass a => a -> IndexList -> IndexList -> SX -> IO ()
sx_indexed_assignment' x = casADi__Matrix_CasADi__SXElement___indexed_assignment' (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___indexed_assignment_TIC_TIC" c_CasADi__Matrix_CasADi__SXElement___indexed_assignment_TIC_TIC
  :: Ptr SX' -> Ptr Slice' -> Ptr IMatrix' -> Ptr SX' -> IO ()
casADi__Matrix_CasADi__SXElement___indexed_assignment''
  :: SX -> Slice -> IMatrix -> SX -> IO ()
casADi__Matrix_CasADi__SXElement___indexed_assignment'' x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  c_CasADi__Matrix_CasADi__SXElement___indexed_assignment_TIC_TIC x0' x1' x2' x3' >>= wrapReturn

-- classy wrapper
sx_indexed_assignment'' :: SXClass a => a -> Slice -> IMatrix -> SX -> IO ()
sx_indexed_assignment'' x = casADi__Matrix_CasADi__SXElement___indexed_assignment'' (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___indexed_assignment_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SXElement___indexed_assignment_TIC_TIC_TIC
  :: Ptr SX' -> Ptr IMatrix' -> Ptr Slice' -> Ptr SX' -> IO ()
casADi__Matrix_CasADi__SXElement___indexed_assignment'''
  :: SX -> IMatrix -> Slice -> SX -> IO ()
casADi__Matrix_CasADi__SXElement___indexed_assignment''' x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  c_CasADi__Matrix_CasADi__SXElement___indexed_assignment_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn

-- classy wrapper
sx_indexed_assignment''' :: SXClass a => a -> IMatrix -> Slice -> SX -> IO ()
sx_indexed_assignment''' x = casADi__Matrix_CasADi__SXElement___indexed_assignment''' (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___indexed_assignment_TIC_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SXElement___indexed_assignment_TIC_TIC_TIC_TIC
  :: Ptr SX' -> Ptr IMatrix' -> Ptr IndexList' -> Ptr SX' -> IO ()
casADi__Matrix_CasADi__SXElement___indexed_assignment''''
  :: SX -> IMatrix -> IndexList -> SX -> IO ()
casADi__Matrix_CasADi__SXElement___indexed_assignment'''' x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  c_CasADi__Matrix_CasADi__SXElement___indexed_assignment_TIC_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn

-- classy wrapper
sx_indexed_assignment'''' :: SXClass a => a -> IMatrix -> IndexList -> SX -> IO ()
sx_indexed_assignment'''' x = casADi__Matrix_CasADi__SXElement___indexed_assignment'''' (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___indexed_assignment_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SXElement___indexed_assignment_TIC_TIC_TIC_TIC_TIC
  :: Ptr SX' -> Ptr IndexList' -> Ptr IMatrix' -> Ptr SX' -> IO ()
casADi__Matrix_CasADi__SXElement___indexed_assignment'''''
  :: SX -> IndexList -> IMatrix -> SX -> IO ()
casADi__Matrix_CasADi__SXElement___indexed_assignment''''' x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  c_CasADi__Matrix_CasADi__SXElement___indexed_assignment_TIC_TIC_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn

-- classy wrapper
sx_indexed_assignment''''' :: SXClass a => a -> IndexList -> IMatrix -> SX -> IO ()
sx_indexed_assignment''''' x = casADi__Matrix_CasADi__SXElement___indexed_assignment''''' (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SXElement___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC
  :: Ptr SX' -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr SX' -> IO ()
casADi__Matrix_CasADi__SXElement___indexed_assignment''''''
  :: SX -> IMatrix -> IMatrix -> SX -> IO ()
casADi__Matrix_CasADi__SXElement___indexed_assignment'''''' x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  c_CasADi__Matrix_CasADi__SXElement___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn

-- classy wrapper
sx_indexed_assignment'''''' :: SXClass a => a -> IMatrix -> IMatrix -> SX -> IO ()
sx_indexed_assignment'''''' x = casADi__Matrix_CasADi__SXElement___indexed_assignment'''''' (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SXElement___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC
  :: Ptr SX' -> Ptr Sparsity' -> Ptr SX' -> IO ()
casADi__Matrix_CasADi__SXElement___indexed_assignment'''''''
  :: SX -> Sparsity -> SX -> IO ()
casADi__Matrix_CasADi__SXElement___indexed_assignment''''''' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_CasADi__SXElement___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
sx_indexed_assignment''''''' :: SXClass a => a -> Sparsity -> SX -> IO ()
sx_indexed_assignment''''''' x = casADi__Matrix_CasADi__SXElement___indexed_assignment''''''' (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___indexed_one_based_assignment_TIC_TIC" c_CasADi__Matrix_CasADi__SXElement___indexed_one_based_assignment_TIC_TIC
  :: Ptr SX' -> CInt -> Ptr SXElement' -> IO ()
casADi__Matrix_CasADi__SXElement___indexed_one_based_assignment''
  :: SX -> Int -> SXElement -> IO ()
casADi__Matrix_CasADi__SXElement___indexed_one_based_assignment'' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_CasADi__SXElement___indexed_one_based_assignment_TIC_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
sx_indexed_one_based_assignment'' :: SXClass a => a -> Int -> SXElement -> IO ()
sx_indexed_one_based_assignment'' x = casADi__Matrix_CasADi__SXElement___indexed_one_based_assignment'' (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___indexed_zero_based_assignment_TIC_TIC" c_CasADi__Matrix_CasADi__SXElement___indexed_zero_based_assignment_TIC_TIC
  :: Ptr SX' -> CInt -> Ptr SXElement' -> IO ()
casADi__Matrix_CasADi__SXElement___indexed_zero_based_assignment''
  :: SX -> Int -> SXElement -> IO ()
casADi__Matrix_CasADi__SXElement___indexed_zero_based_assignment'' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_CasADi__SXElement___indexed_zero_based_assignment_TIC_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
sx_indexed_zero_based_assignment'' :: SXClass a => a -> Int -> SXElement -> IO ()
sx_indexed_zero_based_assignment'' x = casADi__Matrix_CasADi__SXElement___indexed_zero_based_assignment'' (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SXElement___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC
  :: Ptr SX' -> Ptr Slice' -> Ptr SX' -> IO ()
casADi__Matrix_CasADi__SXElement___indexed_assignment''''''''
  :: SX -> Slice -> SX -> IO ()
casADi__Matrix_CasADi__SXElement___indexed_assignment'''''''' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_CasADi__SXElement___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
sx_indexed_assignment'''''''' :: SXClass a => a -> Slice -> SX -> IO ()
sx_indexed_assignment'''''''' x = casADi__Matrix_CasADi__SXElement___indexed_assignment'''''''' (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SXElement___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC
  :: Ptr SX' -> Ptr IndexList' -> Ptr SX' -> IO ()
casADi__Matrix_CasADi__SXElement___indexed_assignment'''''''''
  :: SX -> IndexList -> SX -> IO ()
casADi__Matrix_CasADi__SXElement___indexed_assignment''''''''' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_CasADi__SXElement___indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
sx_indexed_assignment''''''''' :: SXClass a => a -> IndexList -> SX -> IO ()
sx_indexed_assignment''''''''' x = casADi__Matrix_CasADi__SXElement___indexed_assignment''''''''' (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___setZero" c_CasADi__Matrix_CasADi__SXElement___setZero
  :: Ptr SX' -> IO ()
casADi__Matrix_CasADi__SXElement___setZero
  :: SX -> IO ()
casADi__Matrix_CasADi__SXElement___setZero x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SXElement___setZero x0' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Set all elements
>to zero.
-}
sx_setZero :: SXClass a => a -> IO ()
sx_setZero x = casADi__Matrix_CasADi__SXElement___setZero (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___setAll" c_CasADi__Matrix_CasADi__SXElement___setAll
  :: Ptr SX' -> Ptr SXElement' -> IO ()
casADi__Matrix_CasADi__SXElement___setAll
  :: SX -> SXElement -> IO ()
casADi__Matrix_CasADi__SXElement___setAll x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_CasADi__SXElement___setAll x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Set all elements
>to a value.
-}
sx_setAll :: SXClass a => a -> SXElement -> IO ()
sx_setAll x = casADi__Matrix_CasADi__SXElement___setAll (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___setSparse" c_CasADi__Matrix_CasADi__SXElement___setSparse
  :: Ptr SX' -> Ptr Sparsity' -> CInt -> IO (Ptr SX')
casADi__Matrix_CasADi__SXElement___setSparse
  :: SX -> Sparsity -> Bool -> IO SX
casADi__Matrix_CasADi__SXElement___setSparse x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_CasADi__SXElement___setSparse x0' x1' x2' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Set sparse.
-}
sx_setSparse :: SXClass a => a -> Sparsity -> Bool -> IO SX
sx_setSparse x = casADi__Matrix_CasADi__SXElement___setSparse (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___setSparse_TIC" c_CasADi__Matrix_CasADi__SXElement___setSparse_TIC
  :: Ptr SX' -> Ptr Sparsity' -> IO (Ptr SX')
casADi__Matrix_CasADi__SXElement___setSparse'
  :: SX -> Sparsity -> IO SX
casADi__Matrix_CasADi__SXElement___setSparse' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_CasADi__SXElement___setSparse_TIC x0' x1' >>= wrapReturn

-- classy wrapper
sx_setSparse' :: SXClass a => a -> Sparsity -> IO SX
sx_setSparse' x = casADi__Matrix_CasADi__SXElement___setSparse' (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___densify" c_CasADi__Matrix_CasADi__SXElement___densify
  :: Ptr SX' -> Ptr SXElement' -> IO ()
casADi__Matrix_CasADi__SXElement___densify
  :: SX -> SXElement -> IO ()
casADi__Matrix_CasADi__SXElement___densify x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_CasADi__SXElement___densify x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Make the matrix
>dense.
-}
sx_densify :: SXClass a => a -> SXElement -> IO ()
sx_densify x = casADi__Matrix_CasADi__SXElement___densify (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___densify_TIC" c_CasADi__Matrix_CasADi__SXElement___densify_TIC
  :: Ptr SX' -> IO ()
casADi__Matrix_CasADi__SXElement___densify'
  :: SX -> IO ()
casADi__Matrix_CasADi__SXElement___densify' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SXElement___densify_TIC x0' >>= wrapReturn

-- classy wrapper
sx_densify' :: SXClass a => a -> IO ()
sx_densify' x = casADi__Matrix_CasADi__SXElement___densify' (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___sparsify" c_CasADi__Matrix_CasADi__SXElement___sparsify
  :: Ptr SX' -> CDouble -> IO ()
casADi__Matrix_CasADi__SXElement___sparsify
  :: SX -> Double -> IO ()
casADi__Matrix_CasADi__SXElement___sparsify x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_CasADi__SXElement___sparsify x0' x1' >>= wrapReturn

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


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___sparsify_TIC" c_CasADi__Matrix_CasADi__SXElement___sparsify_TIC
  :: Ptr SX' -> IO ()
casADi__Matrix_CasADi__SXElement___sparsify'
  :: SX -> IO ()
casADi__Matrix_CasADi__SXElement___sparsify' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SXElement___sparsify_TIC x0' >>= wrapReturn

-- classy wrapper
sx_sparsify' :: SXClass a => a -> IO ()
sx_sparsify' x = casADi__Matrix_CasADi__SXElement___sparsify' (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___operator_plus" c_CasADi__Matrix_CasADi__SXElement___operator_plus
  :: Ptr SX' -> IO (Ptr SX')
casADi__Matrix_CasADi__SXElement___operator_plus
  :: SX -> IO SX
casADi__Matrix_CasADi__SXElement___operator_plus x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SXElement___operator_plus x0' >>= wrapReturn

-- classy wrapper
sx_operator_plus :: SXClass a => a -> IO SX
sx_operator_plus x = casADi__Matrix_CasADi__SXElement___operator_plus (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___operator_minus" c_CasADi__Matrix_CasADi__SXElement___operator_minus
  :: Ptr SX' -> IO (Ptr SX')
casADi__Matrix_CasADi__SXElement___operator_minus
  :: SX -> IO SX
casADi__Matrix_CasADi__SXElement___operator_minus x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SXElement___operator_minus x0' >>= wrapReturn

-- classy wrapper
sx_operator_minus :: SXClass a => a -> IO SX
sx_operator_minus x = casADi__Matrix_CasADi__SXElement___operator_minus (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___binary" c_CasADi__Matrix_CasADi__SXElement___binary
  :: CInt -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
casADi__Matrix_CasADi__SXElement___binary
  :: Int -> SX -> SX -> IO SX
casADi__Matrix_CasADi__SXElement___binary x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_CasADi__SXElement___binary x0' x1' x2' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Create nodes by
>their ID.
-}
sx_binary :: Int -> SX -> SX -> IO SX
sx_binary = casADi__Matrix_CasADi__SXElement___binary


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___unary" c_CasADi__Matrix_CasADi__SXElement___unary
  :: CInt -> Ptr SX' -> IO (Ptr SX')
casADi__Matrix_CasADi__SXElement___unary
  :: Int -> SX -> IO SX
casADi__Matrix_CasADi__SXElement___unary x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_CasADi__SXElement___unary x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Create nodes by
>their ID.
-}
sx_unary :: Int -> SX -> IO SX
sx_unary = casADi__Matrix_CasADi__SXElement___unary


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___scalar_matrix" c_CasADi__Matrix_CasADi__SXElement___scalar_matrix
  :: CInt -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
casADi__Matrix_CasADi__SXElement___scalar_matrix
  :: Int -> SX -> SX -> IO SX
casADi__Matrix_CasADi__SXElement___scalar_matrix x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_CasADi__SXElement___scalar_matrix x0' x1' x2' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Create
>nodes by their ID.
-}
sx_scalar_matrix :: Int -> SX -> SX -> IO SX
sx_scalar_matrix = casADi__Matrix_CasADi__SXElement___scalar_matrix


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___matrix_scalar" c_CasADi__Matrix_CasADi__SXElement___matrix_scalar
  :: CInt -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
casADi__Matrix_CasADi__SXElement___matrix_scalar
  :: Int -> SX -> SX -> IO SX
casADi__Matrix_CasADi__SXElement___matrix_scalar x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_CasADi__SXElement___matrix_scalar x0' x1' x2' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Create
>nodes by their ID.
-}
sx_matrix_scalar :: Int -> SX -> SX -> IO SX
sx_matrix_scalar = casADi__Matrix_CasADi__SXElement___matrix_scalar


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___matrix_matrix" c_CasADi__Matrix_CasADi__SXElement___matrix_matrix
  :: CInt -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
casADi__Matrix_CasADi__SXElement___matrix_matrix
  :: Int -> SX -> SX -> IO SX
casADi__Matrix_CasADi__SXElement___matrix_matrix x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_CasADi__SXElement___matrix_matrix x0' x1' x2' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Create
>nodes by their ID.
-}
sx_matrix_matrix :: Int -> SX -> SX -> IO SX
sx_matrix_matrix = casADi__Matrix_CasADi__SXElement___matrix_matrix


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement_____add__" c_CasADi__Matrix_CasADi__SXElement_____add__
  :: Ptr SX' -> Ptr SX' -> IO (Ptr SX')
casADi__Matrix_CasADi__SXElement_____add__
  :: SX -> SX -> IO SX
casADi__Matrix_CasADi__SXElement_____add__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_CasADi__SXElement_____add__ x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Elementwise
>operations Octave/Python naming.
-}
sx___add__ :: SXClass a => a -> SX -> IO SX
sx___add__ x = casADi__Matrix_CasADi__SXElement_____add__ (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement_____sub__" c_CasADi__Matrix_CasADi__SXElement_____sub__
  :: Ptr SX' -> Ptr SX' -> IO (Ptr SX')
casADi__Matrix_CasADi__SXElement_____sub__
  :: SX -> SX -> IO SX
casADi__Matrix_CasADi__SXElement_____sub__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_CasADi__SXElement_____sub__ x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Elementwise
>operations Octave/Python naming.
-}
sx___sub__ :: SXClass a => a -> SX -> IO SX
sx___sub__ x = casADi__Matrix_CasADi__SXElement_____sub__ (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement_____mul__" c_CasADi__Matrix_CasADi__SXElement_____mul__
  :: Ptr SX' -> Ptr SX' -> IO (Ptr SX')
casADi__Matrix_CasADi__SXElement_____mul__
  :: SX -> SX -> IO SX
casADi__Matrix_CasADi__SXElement_____mul__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_CasADi__SXElement_____mul__ x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Elementwise
>operations Octave/Python naming.
-}
sx___mul__ :: SXClass a => a -> SX -> IO SX
sx___mul__ x = casADi__Matrix_CasADi__SXElement_____mul__ (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement_____div__" c_CasADi__Matrix_CasADi__SXElement_____div__
  :: Ptr SX' -> Ptr SX' -> IO (Ptr SX')
casADi__Matrix_CasADi__SXElement_____div__
  :: SX -> SX -> IO SX
casADi__Matrix_CasADi__SXElement_____div__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_CasADi__SXElement_____div__ x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Elementwise
>operations Octave/Python naming.
-}
sx___div__ :: SXClass a => a -> SX -> IO SX
sx___div__ x = casADi__Matrix_CasADi__SXElement_____div__ (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement_____lt__" c_CasADi__Matrix_CasADi__SXElement_____lt__
  :: Ptr SX' -> Ptr SX' -> IO (Ptr SX')
casADi__Matrix_CasADi__SXElement_____lt__
  :: SX -> SX -> IO SX
casADi__Matrix_CasADi__SXElement_____lt__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_CasADi__SXElement_____lt__ x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Elementwise
>operations Octave/Python naming.
-}
sx___lt__ :: SXClass a => a -> SX -> IO SX
sx___lt__ x = casADi__Matrix_CasADi__SXElement_____lt__ (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement_____le__" c_CasADi__Matrix_CasADi__SXElement_____le__
  :: Ptr SX' -> Ptr SX' -> IO (Ptr SX')
casADi__Matrix_CasADi__SXElement_____le__
  :: SX -> SX -> IO SX
casADi__Matrix_CasADi__SXElement_____le__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_CasADi__SXElement_____le__ x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Elementwise
>operations Octave/Python naming.
-}
sx___le__ :: SXClass a => a -> SX -> IO SX
sx___le__ x = casADi__Matrix_CasADi__SXElement_____le__ (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement_____eq__" c_CasADi__Matrix_CasADi__SXElement_____eq__
  :: Ptr SX' -> Ptr SX' -> IO (Ptr SX')
casADi__Matrix_CasADi__SXElement_____eq__
  :: SX -> SX -> IO SX
casADi__Matrix_CasADi__SXElement_____eq__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_CasADi__SXElement_____eq__ x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Elementwise
>operations Octave/Python naming.
-}
sx___eq__ :: SXClass a => a -> SX -> IO SX
sx___eq__ x = casADi__Matrix_CasADi__SXElement_____eq__ (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement_____ne__" c_CasADi__Matrix_CasADi__SXElement_____ne__
  :: Ptr SX' -> Ptr SX' -> IO (Ptr SX')
casADi__Matrix_CasADi__SXElement_____ne__
  :: SX -> SX -> IO SX
casADi__Matrix_CasADi__SXElement_____ne__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_CasADi__SXElement_____ne__ x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Elementwise
>operations Octave/Python naming.
-}
sx___ne__ :: SXClass a => a -> SX -> IO SX
sx___ne__ x = casADi__Matrix_CasADi__SXElement_____ne__ (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement_____truediv__" c_CasADi__Matrix_CasADi__SXElement_____truediv__
  :: Ptr SX' -> Ptr SX' -> IO (Ptr SX')
casADi__Matrix_CasADi__SXElement_____truediv__
  :: SX -> SX -> IO SX
casADi__Matrix_CasADi__SXElement_____truediv__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_CasADi__SXElement_____truediv__ x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Elementwise
>operations Octave/Python naming.
-}
sx___truediv__ :: SXClass a => a -> SX -> IO SX
sx___truediv__ x = casADi__Matrix_CasADi__SXElement_____truediv__ (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement_____pow__" c_CasADi__Matrix_CasADi__SXElement_____pow__
  :: Ptr SX' -> Ptr SX' -> IO (Ptr SX')
casADi__Matrix_CasADi__SXElement_____pow__
  :: SX -> SX -> IO SX
casADi__Matrix_CasADi__SXElement_____pow__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_CasADi__SXElement_____pow__ x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Elementwise
>operations Octave/Python naming.
-}
sx___pow__ :: SXClass a => a -> SX -> IO SX
sx___pow__ x = casADi__Matrix_CasADi__SXElement_____pow__ (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement_____constpow__" c_CasADi__Matrix_CasADi__SXElement_____constpow__
  :: Ptr SX' -> Ptr SX' -> IO (Ptr SX')
casADi__Matrix_CasADi__SXElement_____constpow__
  :: SX -> SX -> IO SX
casADi__Matrix_CasADi__SXElement_____constpow__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_CasADi__SXElement_____constpow__ x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Elementwise
>operations Octave/Python naming.
-}
sx___constpow__ :: SXClass a => a -> SX -> IO SX
sx___constpow__ x = casADi__Matrix_CasADi__SXElement_____constpow__ (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement_____mpower__" c_CasADi__Matrix_CasADi__SXElement_____mpower__
  :: Ptr SX' -> Ptr SX' -> IO (Ptr SX')
casADi__Matrix_CasADi__SXElement_____mpower__
  :: SX -> SX -> IO SX
casADi__Matrix_CasADi__SXElement_____mpower__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_CasADi__SXElement_____mpower__ x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Elementwise
>operations Octave/Python naming.
-}
sx___mpower__ :: SXClass a => a -> SX -> IO SX
sx___mpower__ x = casADi__Matrix_CasADi__SXElement_____mpower__ (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement_____mrdivide__" c_CasADi__Matrix_CasADi__SXElement_____mrdivide__
  :: Ptr SX' -> Ptr SX' -> IO (Ptr SX')
casADi__Matrix_CasADi__SXElement_____mrdivide__
  :: SX -> SX -> IO SX
casADi__Matrix_CasADi__SXElement_____mrdivide__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_CasADi__SXElement_____mrdivide__ x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Elementwise
>operations Octave/Python naming.
-}
sx___mrdivide__ :: SXClass a => a -> SX -> IO SX
sx___mrdivide__ x = casADi__Matrix_CasADi__SXElement_____mrdivide__ (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___mul_full" c_CasADi__Matrix_CasADi__SXElement___mul_full
  :: Ptr SX' -> Ptr SX' -> Ptr Sparsity' -> IO (Ptr SX')
casADi__Matrix_CasADi__SXElement___mul_full
  :: SX -> SX -> Sparsity -> IO SX
casADi__Matrix_CasADi__SXElement___mul_full x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_CasADi__SXElement___mul_full x0' x1' x2' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Matrix-matrix
>product.
-}
sx_mul_full :: SXClass a => a -> SX -> Sparsity -> IO SX
sx_mul_full x = casADi__Matrix_CasADi__SXElement___mul_full (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___mul_full_TIC" c_CasADi__Matrix_CasADi__SXElement___mul_full_TIC
  :: Ptr SX' -> Ptr SX' -> IO (Ptr SX')
casADi__Matrix_CasADi__SXElement___mul_full'
  :: SX -> SX -> IO SX
casADi__Matrix_CasADi__SXElement___mul_full' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_CasADi__SXElement___mul_full_TIC x0' x1' >>= wrapReturn

-- classy wrapper
sx_mul_full' :: SXClass a => a -> SX -> IO SX
sx_mul_full' x = casADi__Matrix_CasADi__SXElement___mul_full' (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___mul" c_CasADi__Matrix_CasADi__SXElement___mul
  :: Ptr SX' -> Ptr SX' -> Ptr Sparsity' -> IO (Ptr SX')
casADi__Matrix_CasADi__SXElement___mul
  :: SX -> SX -> Sparsity -> IO SX
casADi__Matrix_CasADi__SXElement___mul x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_CasADi__SXElement___mul x0' x1' x2' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Matrix-matrix
>product.
-}
sx_mul :: SXClass a => a -> SX -> Sparsity -> IO SX
sx_mul x = casADi__Matrix_CasADi__SXElement___mul (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___mul_TIC" c_CasADi__Matrix_CasADi__SXElement___mul_TIC
  :: Ptr SX' -> Ptr SX' -> IO (Ptr SX')
casADi__Matrix_CasADi__SXElement___mul'
  :: SX -> SX -> IO SX
casADi__Matrix_CasADi__SXElement___mul' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_CasADi__SXElement___mul_TIC x0' x1' >>= wrapReturn

-- classy wrapper
sx_mul' :: SXClass a => a -> SX -> IO SX
sx_mul' x = casADi__Matrix_CasADi__SXElement___mul' (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___mul_no_alloc_nn" c_CasADi__Matrix_CasADi__SXElement___mul_no_alloc_nn
  :: Ptr SX' -> Ptr SX' -> Ptr SX' -> IO ()
casADi__Matrix_CasADi__SXElement___mul_no_alloc_nn
  :: SX -> SX -> SX -> IO ()
casADi__Matrix_CasADi__SXElement___mul_no_alloc_nn x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_CasADi__SXElement___mul_no_alloc_nn x0' x1' x2' >>= wrapReturn

-- classy wrapper
sx_mul_no_alloc_nn :: SX -> SX -> SX -> IO ()
sx_mul_no_alloc_nn = casADi__Matrix_CasADi__SXElement___mul_no_alloc_nn


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___mul_no_alloc_tn" c_CasADi__Matrix_CasADi__SXElement___mul_no_alloc_tn
  :: Ptr SX' -> Ptr SX' -> Ptr SX' -> IO ()
casADi__Matrix_CasADi__SXElement___mul_no_alloc_tn
  :: SX -> SX -> SX -> IO ()
casADi__Matrix_CasADi__SXElement___mul_no_alloc_tn x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_CasADi__SXElement___mul_no_alloc_tn x0' x1' x2' >>= wrapReturn

-- classy wrapper
sx_mul_no_alloc_tn :: SX -> SX -> SX -> IO ()
sx_mul_no_alloc_tn = casADi__Matrix_CasADi__SXElement___mul_no_alloc_tn


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___mul_no_alloc_nt" c_CasADi__Matrix_CasADi__SXElement___mul_no_alloc_nt
  :: Ptr SX' -> Ptr SX' -> Ptr SX' -> IO ()
casADi__Matrix_CasADi__SXElement___mul_no_alloc_nt
  :: SX -> SX -> SX -> IO ()
casADi__Matrix_CasADi__SXElement___mul_no_alloc_nt x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_CasADi__SXElement___mul_no_alloc_nt x0' x1' x2' >>= wrapReturn

-- classy wrapper
sx_mul_no_alloc_nt :: SX -> SX -> SX -> IO ()
sx_mul_no_alloc_nt = casADi__Matrix_CasADi__SXElement___mul_no_alloc_nt


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___mul_no_alloc_tn_TIC" c_CasADi__Matrix_CasADi__SXElement___mul_no_alloc_tn_TIC
  :: Ptr SX' -> Ptr (CppVec (Ptr SXElement')) -> Ptr (CppVec (Ptr SXElement')) -> IO ()
casADi__Matrix_CasADi__SXElement___mul_no_alloc_tn'
  :: SX -> Vector SXElement -> Vector SXElement -> IO ()
casADi__Matrix_CasADi__SXElement___mul_no_alloc_tn' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_CasADi__SXElement___mul_no_alloc_tn_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
sx_mul_no_alloc_tn' :: SX -> Vector SXElement -> Vector SXElement -> IO ()
sx_mul_no_alloc_tn' = casADi__Matrix_CasADi__SXElement___mul_no_alloc_tn'


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___mul_no_alloc_nn_TIC" c_CasADi__Matrix_CasADi__SXElement___mul_no_alloc_nn_TIC
  :: Ptr SX' -> Ptr (CppVec (Ptr SXElement')) -> Ptr (CppVec (Ptr SXElement')) -> IO ()
casADi__Matrix_CasADi__SXElement___mul_no_alloc_nn'
  :: SX -> Vector SXElement -> Vector SXElement -> IO ()
casADi__Matrix_CasADi__SXElement___mul_no_alloc_nn' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_CasADi__SXElement___mul_no_alloc_nn_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
sx_mul_no_alloc_nn' :: SX -> Vector SXElement -> Vector SXElement -> IO ()
sx_mul_no_alloc_nn' = casADi__Matrix_CasADi__SXElement___mul_no_alloc_nn'


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___quad_form" c_CasADi__Matrix_CasADi__SXElement___quad_form
  :: Ptr SX' -> Ptr (CppVec (Ptr SXElement')) -> IO (Ptr SXElement')
casADi__Matrix_CasADi__SXElement___quad_form
  :: SX -> Vector SXElement -> IO SXElement
casADi__Matrix_CasADi__SXElement___quad_form x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_CasADi__SXElement___quad_form x0' x1' >>= wrapReturn

-- classy wrapper
sx_quad_form :: SX -> Vector SXElement -> IO SXElement
sx_quad_form = casADi__Matrix_CasADi__SXElement___quad_form


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___trans" c_CasADi__Matrix_CasADi__SXElement___trans
  :: Ptr SX' -> IO (Ptr SX')
casADi__Matrix_CasADi__SXElement___trans
  :: SX -> IO SX
casADi__Matrix_CasADi__SXElement___trans x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SXElement___trans x0' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]   Transpose the
>matrix.
-}
sx_trans :: SXClass a => a -> IO SX
sx_trans x = casADi__Matrix_CasADi__SXElement___trans (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___sin" c_CasADi__Matrix_CasADi__SXElement___sin
  :: Ptr SX' -> IO (Ptr SX')
casADi__Matrix_CasADi__SXElement___sin
  :: SX -> IO SX
casADi__Matrix_CasADi__SXElement___sin x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SXElement___sin x0' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Operations defined
>in the standard namespace for unambigous access and Numpy compatibility.
-}
sx_sin :: SXClass a => a -> IO SX
sx_sin x = casADi__Matrix_CasADi__SXElement___sin (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___cos" c_CasADi__Matrix_CasADi__SXElement___cos
  :: Ptr SX' -> IO (Ptr SX')
casADi__Matrix_CasADi__SXElement___cos
  :: SX -> IO SX
casADi__Matrix_CasADi__SXElement___cos x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SXElement___cos x0' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Operations defined
>in the standard namespace for unambigous access and Numpy compatibility.
-}
sx_cos :: SXClass a => a -> IO SX
sx_cos x = casADi__Matrix_CasADi__SXElement___cos (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___tan" c_CasADi__Matrix_CasADi__SXElement___tan
  :: Ptr SX' -> IO (Ptr SX')
casADi__Matrix_CasADi__SXElement___tan
  :: SX -> IO SX
casADi__Matrix_CasADi__SXElement___tan x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SXElement___tan x0' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Operations defined
>in the standard namespace for unambigous access and Numpy compatibility.
-}
sx_tan :: SXClass a => a -> IO SX
sx_tan x = casADi__Matrix_CasADi__SXElement___tan (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___arcsin" c_CasADi__Matrix_CasADi__SXElement___arcsin
  :: Ptr SX' -> IO (Ptr SX')
casADi__Matrix_CasADi__SXElement___arcsin
  :: SX -> IO SX
casADi__Matrix_CasADi__SXElement___arcsin x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SXElement___arcsin x0' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Operations
>defined in the standard namespace for unambigous access and Numpy
>compatibility.
-}
sx_arcsin :: SXClass a => a -> IO SX
sx_arcsin x = casADi__Matrix_CasADi__SXElement___arcsin (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___arccos" c_CasADi__Matrix_CasADi__SXElement___arccos
  :: Ptr SX' -> IO (Ptr SX')
casADi__Matrix_CasADi__SXElement___arccos
  :: SX -> IO SX
casADi__Matrix_CasADi__SXElement___arccos x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SXElement___arccos x0' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Operations
>defined in the standard namespace for unambigous access and Numpy
>compatibility.
-}
sx_arccos :: SXClass a => a -> IO SX
sx_arccos x = casADi__Matrix_CasADi__SXElement___arccos (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___arctan" c_CasADi__Matrix_CasADi__SXElement___arctan
  :: Ptr SX' -> IO (Ptr SX')
casADi__Matrix_CasADi__SXElement___arctan
  :: SX -> IO SX
casADi__Matrix_CasADi__SXElement___arctan x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SXElement___arctan x0' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Operations
>defined in the standard namespace for unambigous access and Numpy
>compatibility.
-}
sx_arctan :: SXClass a => a -> IO SX
sx_arctan x = casADi__Matrix_CasADi__SXElement___arctan (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___exp" c_CasADi__Matrix_CasADi__SXElement___exp
  :: Ptr SX' -> IO (Ptr SX')
casADi__Matrix_CasADi__SXElement___exp
  :: SX -> IO SX
casADi__Matrix_CasADi__SXElement___exp x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SXElement___exp x0' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Operations defined
>in the standard namespace for unambigous access and Numpy compatibility.
-}
sx_exp :: SXClass a => a -> IO SX
sx_exp x = casADi__Matrix_CasADi__SXElement___exp (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___log" c_CasADi__Matrix_CasADi__SXElement___log
  :: Ptr SX' -> IO (Ptr SX')
casADi__Matrix_CasADi__SXElement___log
  :: SX -> IO SX
casADi__Matrix_CasADi__SXElement___log x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SXElement___log x0' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Operations defined
>in the standard namespace for unambigous access and Numpy compatibility.
-}
sx_log :: SXClass a => a -> IO SX
sx_log x = casADi__Matrix_CasADi__SXElement___log (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___sqrt" c_CasADi__Matrix_CasADi__SXElement___sqrt
  :: Ptr SX' -> IO (Ptr SX')
casADi__Matrix_CasADi__SXElement___sqrt
  :: SX -> IO SX
casADi__Matrix_CasADi__SXElement___sqrt x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SXElement___sqrt x0' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Operations defined
>in the standard namespace for unambigous access and Numpy compatibility.
-}
sx_sqrt :: SXClass a => a -> IO SX
sx_sqrt x = casADi__Matrix_CasADi__SXElement___sqrt (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___floor" c_CasADi__Matrix_CasADi__SXElement___floor
  :: Ptr SX' -> IO (Ptr SX')
casADi__Matrix_CasADi__SXElement___floor
  :: SX -> IO SX
casADi__Matrix_CasADi__SXElement___floor x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SXElement___floor x0' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Operations defined
>in the standard namespace for unambigous access and Numpy compatibility.
-}
sx_floor :: SXClass a => a -> IO SX
sx_floor x = casADi__Matrix_CasADi__SXElement___floor (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___ceil" c_CasADi__Matrix_CasADi__SXElement___ceil
  :: Ptr SX' -> IO (Ptr SX')
casADi__Matrix_CasADi__SXElement___ceil
  :: SX -> IO SX
casADi__Matrix_CasADi__SXElement___ceil x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SXElement___ceil x0' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Operations defined
>in the standard namespace for unambigous access and Numpy compatibility.
-}
sx_ceil :: SXClass a => a -> IO SX
sx_ceil x = casADi__Matrix_CasADi__SXElement___ceil (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___fabs" c_CasADi__Matrix_CasADi__SXElement___fabs
  :: Ptr SX' -> IO (Ptr SX')
casADi__Matrix_CasADi__SXElement___fabs
  :: SX -> IO SX
casADi__Matrix_CasADi__SXElement___fabs x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SXElement___fabs x0' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Operations defined
>in the standard namespace for unambigous access and Numpy compatibility.
-}
sx_fabs :: SXClass a => a -> IO SX
sx_fabs x = casADi__Matrix_CasADi__SXElement___fabs (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___sign" c_CasADi__Matrix_CasADi__SXElement___sign
  :: Ptr SX' -> IO (Ptr SX')
casADi__Matrix_CasADi__SXElement___sign
  :: SX -> IO SX
casADi__Matrix_CasADi__SXElement___sign x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SXElement___sign x0' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Operations defined
>in the standard namespace for unambigous access and Numpy compatibility.
-}
sx_sign :: SXClass a => a -> IO SX
sx_sign x = casADi__Matrix_CasADi__SXElement___sign (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement_____copysign__" c_CasADi__Matrix_CasADi__SXElement_____copysign__
  :: Ptr SX' -> Ptr SX' -> IO (Ptr SX')
casADi__Matrix_CasADi__SXElement_____copysign__
  :: SX -> SX -> IO SX
casADi__Matrix_CasADi__SXElement_____copysign__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_CasADi__SXElement_____copysign__ x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Operations
>defined in the standard namespace for unambigous access and Numpy
>compatibility.
-}
sx___copysign__ :: SXClass a => a -> SX -> IO SX
sx___copysign__ x = casADi__Matrix_CasADi__SXElement_____copysign__ (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___erfinv" c_CasADi__Matrix_CasADi__SXElement___erfinv
  :: Ptr SX' -> IO (Ptr SX')
casADi__Matrix_CasADi__SXElement___erfinv
  :: SX -> IO SX
casADi__Matrix_CasADi__SXElement___erfinv x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SXElement___erfinv x0' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Operations
>defined in the standard namespace for unambigous access and Numpy
>compatibility.
-}
sx_erfinv :: SXClass a => a -> IO SX
sx_erfinv x = casADi__Matrix_CasADi__SXElement___erfinv (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___fmin" c_CasADi__Matrix_CasADi__SXElement___fmin
  :: Ptr SX' -> Ptr SX' -> IO (Ptr SX')
casADi__Matrix_CasADi__SXElement___fmin
  :: SX -> SX -> IO SX
casADi__Matrix_CasADi__SXElement___fmin x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_CasADi__SXElement___fmin x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Operations defined
>in the standard namespace for unambigous access and Numpy compatibility.
-}
sx_fmin :: SXClass a => a -> SX -> IO SX
sx_fmin x = casADi__Matrix_CasADi__SXElement___fmin (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___fmax" c_CasADi__Matrix_CasADi__SXElement___fmax
  :: Ptr SX' -> Ptr SX' -> IO (Ptr SX')
casADi__Matrix_CasADi__SXElement___fmax
  :: SX -> SX -> IO SX
casADi__Matrix_CasADi__SXElement___fmax x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_CasADi__SXElement___fmax x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Operations defined
>in the standard namespace for unambigous access and Numpy compatibility.
-}
sx_fmax :: SXClass a => a -> SX -> IO SX
sx_fmax x = casADi__Matrix_CasADi__SXElement___fmax (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___erf" c_CasADi__Matrix_CasADi__SXElement___erf
  :: Ptr SX' -> IO (Ptr SX')
casADi__Matrix_CasADi__SXElement___erf
  :: SX -> IO SX
casADi__Matrix_CasADi__SXElement___erf x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SXElement___erf x0' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Operations defined
>in the standard namespace for unambigous access and Numpy compatibility.
-}
sx_erf :: SXClass a => a -> IO SX
sx_erf x = casADi__Matrix_CasADi__SXElement___erf (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___sinh" c_CasADi__Matrix_CasADi__SXElement___sinh
  :: Ptr SX' -> IO (Ptr SX')
casADi__Matrix_CasADi__SXElement___sinh
  :: SX -> IO SX
casADi__Matrix_CasADi__SXElement___sinh x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SXElement___sinh x0' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Operations defined
>in the standard namespace for unambigous access and Numpy compatibility.
-}
sx_sinh :: SXClass a => a -> IO SX
sx_sinh x = casADi__Matrix_CasADi__SXElement___sinh (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___cosh" c_CasADi__Matrix_CasADi__SXElement___cosh
  :: Ptr SX' -> IO (Ptr SX')
casADi__Matrix_CasADi__SXElement___cosh
  :: SX -> IO SX
casADi__Matrix_CasADi__SXElement___cosh x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SXElement___cosh x0' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Operations defined
>in the standard namespace for unambigous access and Numpy compatibility.
-}
sx_cosh :: SXClass a => a -> IO SX
sx_cosh x = casADi__Matrix_CasADi__SXElement___cosh (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___tanh" c_CasADi__Matrix_CasADi__SXElement___tanh
  :: Ptr SX' -> IO (Ptr SX')
casADi__Matrix_CasADi__SXElement___tanh
  :: SX -> IO SX
casADi__Matrix_CasADi__SXElement___tanh x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SXElement___tanh x0' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Operations defined
>in the standard namespace for unambigous access and Numpy compatibility.
-}
sx_tanh :: SXClass a => a -> IO SX
sx_tanh x = casADi__Matrix_CasADi__SXElement___tanh (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___arcsinh" c_CasADi__Matrix_CasADi__SXElement___arcsinh
  :: Ptr SX' -> IO (Ptr SX')
casADi__Matrix_CasADi__SXElement___arcsinh
  :: SX -> IO SX
casADi__Matrix_CasADi__SXElement___arcsinh x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SXElement___arcsinh x0' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Operations
>defined in the standard namespace for unambigous access and Numpy
>compatibility.
-}
sx_arcsinh :: SXClass a => a -> IO SX
sx_arcsinh x = casADi__Matrix_CasADi__SXElement___arcsinh (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___arccosh" c_CasADi__Matrix_CasADi__SXElement___arccosh
  :: Ptr SX' -> IO (Ptr SX')
casADi__Matrix_CasADi__SXElement___arccosh
  :: SX -> IO SX
casADi__Matrix_CasADi__SXElement___arccosh x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SXElement___arccosh x0' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Operations
>defined in the standard namespace for unambigous access and Numpy
>compatibility.
-}
sx_arccosh :: SXClass a => a -> IO SX
sx_arccosh x = casADi__Matrix_CasADi__SXElement___arccosh (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___arctanh" c_CasADi__Matrix_CasADi__SXElement___arctanh
  :: Ptr SX' -> IO (Ptr SX')
casADi__Matrix_CasADi__SXElement___arctanh
  :: SX -> IO SX
casADi__Matrix_CasADi__SXElement___arctanh x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SXElement___arctanh x0' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Operations
>defined in the standard namespace for unambigous access and Numpy
>compatibility.
-}
sx_arctanh :: SXClass a => a -> IO SX
sx_arctanh x = casADi__Matrix_CasADi__SXElement___arctanh (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___arctan2" c_CasADi__Matrix_CasADi__SXElement___arctan2
  :: Ptr SX' -> Ptr SX' -> IO (Ptr SX')
casADi__Matrix_CasADi__SXElement___arctan2
  :: SX -> SX -> IO SX
casADi__Matrix_CasADi__SXElement___arctan2 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_CasADi__SXElement___arctan2 x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Operations
>defined in the standard namespace for unambigous access and Numpy
>compatibility.
-}
sx_arctan2 :: SXClass a => a -> SX -> IO SX
sx_arctan2 x = casADi__Matrix_CasADi__SXElement___arctan2 (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___log10" c_CasADi__Matrix_CasADi__SXElement___log10
  :: Ptr SX' -> IO (Ptr SX')
casADi__Matrix_CasADi__SXElement___log10
  :: SX -> IO SX
casADi__Matrix_CasADi__SXElement___log10 x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SXElement___log10 x0' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Operations defined
>in the standard namespace for unambigous access and Numpy compatibility.
-}
sx_log10 :: SXClass a => a -> IO SX
sx_log10 x = casADi__Matrix_CasADi__SXElement___log10 (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___printme" c_CasADi__Matrix_CasADi__SXElement___printme
  :: Ptr SX' -> Ptr SX' -> IO (Ptr SX')
casADi__Matrix_CasADi__SXElement___printme
  :: SX -> SX -> IO SX
casADi__Matrix_CasADi__SXElement___printme x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_CasADi__SXElement___printme x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Operations
>defined in the standard namespace for unambigous access and Numpy
>compatibility.
-}
sx_printme :: SXClass a => a -> SX -> IO SX
sx_printme x = casADi__Matrix_CasADi__SXElement___printme (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___logic_not" c_CasADi__Matrix_CasADi__SXElement___logic_not
  :: Ptr SX' -> IO (Ptr SX')
casADi__Matrix_CasADi__SXElement___logic_not
  :: SX -> IO SX
casADi__Matrix_CasADi__SXElement___logic_not x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SXElement___logic_not x0' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Operations
>defined in the standard namespace for unambigous access and Numpy
>compatibility.
-}
sx_logic_not :: SXClass a => a -> IO SX
sx_logic_not x = casADi__Matrix_CasADi__SXElement___logic_not (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___logic_and" c_CasADi__Matrix_CasADi__SXElement___logic_and
  :: Ptr SX' -> Ptr SX' -> IO (Ptr SX')
casADi__Matrix_CasADi__SXElement___logic_and
  :: SX -> SX -> IO SX
casADi__Matrix_CasADi__SXElement___logic_and x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_CasADi__SXElement___logic_and x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Operations
>defined in the standard namespace for unambigous access and Numpy
>compatibility.
-}
sx_logic_and :: SXClass a => a -> SX -> IO SX
sx_logic_and x = casADi__Matrix_CasADi__SXElement___logic_and (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___logic_or" c_CasADi__Matrix_CasADi__SXElement___logic_or
  :: Ptr SX' -> Ptr SX' -> IO (Ptr SX')
casADi__Matrix_CasADi__SXElement___logic_or
  :: SX -> SX -> IO SX
casADi__Matrix_CasADi__SXElement___logic_or x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_CasADi__SXElement___logic_or x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Operations
>defined in the standard namespace for unambigous access and Numpy
>compatibility.
-}
sx_logic_or :: SXClass a => a -> SX -> IO SX
sx_logic_or x = casADi__Matrix_CasADi__SXElement___logic_or (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___if_else_zero" c_CasADi__Matrix_CasADi__SXElement___if_else_zero
  :: Ptr SX' -> Ptr SX' -> IO (Ptr SX')
casADi__Matrix_CasADi__SXElement___if_else_zero
  :: SX -> SX -> IO SX
casADi__Matrix_CasADi__SXElement___if_else_zero x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_CasADi__SXElement___if_else_zero x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Operations
>defined in the standard namespace for unambigous access and Numpy
>compatibility.
-}
sx_if_else_zero :: SXClass a => a -> SX -> IO SX
sx_if_else_zero x = casADi__Matrix_CasADi__SXElement___if_else_zero (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___setMaxNumCallsInPrint" c_CasADi__Matrix_CasADi__SXElement___setMaxNumCallsInPrint
  :: CLong -> IO ()
casADi__Matrix_CasADi__SXElement___setMaxNumCallsInPrint
  :: Int -> IO ()
casADi__Matrix_CasADi__SXElement___setMaxNumCallsInPrint x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SXElement___setMaxNumCallsInPrint x0' >>= wrapReturn

-- classy wrapper
sx_setMaxNumCallsInPrint :: Int -> IO ()
sx_setMaxNumCallsInPrint = casADi__Matrix_CasADi__SXElement___setMaxNumCallsInPrint


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___setMaxNumCallsInPrint_TIC" c_CasADi__Matrix_CasADi__SXElement___setMaxNumCallsInPrint_TIC
  :: IO ()
casADi__Matrix_CasADi__SXElement___setMaxNumCallsInPrint'
  :: IO ()
casADi__Matrix_CasADi__SXElement___setMaxNumCallsInPrint'  =
  c_CasADi__Matrix_CasADi__SXElement___setMaxNumCallsInPrint_TIC  >>= wrapReturn

-- classy wrapper
sx_setMaxNumCallsInPrint' :: IO ()
sx_setMaxNumCallsInPrint' = casADi__Matrix_CasADi__SXElement___setMaxNumCallsInPrint'


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___getMaxNumCallsInPrint" c_CasADi__Matrix_CasADi__SXElement___getMaxNumCallsInPrint
  :: IO CLong
casADi__Matrix_CasADi__SXElement___getMaxNumCallsInPrint
  :: IO Int
casADi__Matrix_CasADi__SXElement___getMaxNumCallsInPrint  =
  c_CasADi__Matrix_CasADi__SXElement___getMaxNumCallsInPrint  >>= wrapReturn

-- classy wrapper
sx_getMaxNumCallsInPrint :: IO Int
sx_getMaxNumCallsInPrint = casADi__Matrix_CasADi__SXElement___getMaxNumCallsInPrint


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___setEqualityCheckingDepth" c_CasADi__Matrix_CasADi__SXElement___setEqualityCheckingDepth
  :: CInt -> IO ()
casADi__Matrix_CasADi__SXElement___setEqualityCheckingDepth
  :: Int -> IO ()
casADi__Matrix_CasADi__SXElement___setEqualityCheckingDepth x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SXElement___setEqualityCheckingDepth x0' >>= wrapReturn

-- classy wrapper
sx_setEqualityCheckingDepth :: Int -> IO ()
sx_setEqualityCheckingDepth = casADi__Matrix_CasADi__SXElement___setEqualityCheckingDepth


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___setEqualityCheckingDepth_TIC" c_CasADi__Matrix_CasADi__SXElement___setEqualityCheckingDepth_TIC
  :: IO ()
casADi__Matrix_CasADi__SXElement___setEqualityCheckingDepth'
  :: IO ()
casADi__Matrix_CasADi__SXElement___setEqualityCheckingDepth'  =
  c_CasADi__Matrix_CasADi__SXElement___setEqualityCheckingDepth_TIC  >>= wrapReturn

-- classy wrapper
sx_setEqualityCheckingDepth' :: IO ()
sx_setEqualityCheckingDepth' = casADi__Matrix_CasADi__SXElement___setEqualityCheckingDepth'


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___getEqualityCheckingDepth" c_CasADi__Matrix_CasADi__SXElement___getEqualityCheckingDepth
  :: IO CInt
casADi__Matrix_CasADi__SXElement___getEqualityCheckingDepth
  :: IO Int
casADi__Matrix_CasADi__SXElement___getEqualityCheckingDepth  =
  c_CasADi__Matrix_CasADi__SXElement___getEqualityCheckingDepth  >>= wrapReturn

-- classy wrapper
sx_getEqualityCheckingDepth :: IO Int
sx_getEqualityCheckingDepth = casADi__Matrix_CasADi__SXElement___getEqualityCheckingDepth


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___className" c_CasADi__Matrix_CasADi__SXElement___className
  :: IO (Ptr StdString')
casADi__Matrix_CasADi__SXElement___className
  :: IO String
casADi__Matrix_CasADi__SXElement___className  =
  c_CasADi__Matrix_CasADi__SXElement___className  >>= wrapReturn

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


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___printScalar_TIC" c_CasADi__Matrix_CasADi__SXElement___printScalar_TIC
  :: Ptr SX' -> IO ()
casADi__Matrix_CasADi__SXElement___printScalar'
  :: SX -> IO ()
casADi__Matrix_CasADi__SXElement___printScalar' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SXElement___printScalar_TIC x0' >>= wrapReturn

-- classy wrapper
sx_printScalar' :: SXClass a => a -> IO ()
sx_printScalar' x = casADi__Matrix_CasADi__SXElement___printScalar' (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___printVector_TIC" c_CasADi__Matrix_CasADi__SXElement___printVector_TIC
  :: Ptr SX' -> IO ()
casADi__Matrix_CasADi__SXElement___printVector'
  :: SX -> IO ()
casADi__Matrix_CasADi__SXElement___printVector' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SXElement___printVector_TIC x0' >>= wrapReturn

-- classy wrapper
sx_printVector' :: SXClass a => a -> IO ()
sx_printVector' x = casADi__Matrix_CasADi__SXElement___printVector' (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___printDense_TIC" c_CasADi__Matrix_CasADi__SXElement___printDense_TIC
  :: Ptr SX' -> IO ()
casADi__Matrix_CasADi__SXElement___printDense'
  :: SX -> IO ()
casADi__Matrix_CasADi__SXElement___printDense' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SXElement___printDense_TIC x0' >>= wrapReturn

-- classy wrapper
sx_printDense' :: SXClass a => a -> IO ()
sx_printDense' x = casADi__Matrix_CasADi__SXElement___printDense' (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___printSparse_TIC" c_CasADi__Matrix_CasADi__SXElement___printSparse_TIC
  :: Ptr SX' -> IO ()
casADi__Matrix_CasADi__SXElement___printSparse'
  :: SX -> IO ()
casADi__Matrix_CasADi__SXElement___printSparse' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SXElement___printSparse_TIC x0' >>= wrapReturn

-- classy wrapper
sx_printSparse' :: SXClass a => a -> IO ()
sx_printSparse' x = casADi__Matrix_CasADi__SXElement___printSparse' (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___row" c_CasADi__Matrix_CasADi__SXElement___row
  :: Ptr SX' -> CInt -> IO CInt
casADi__Matrix_CasADi__SXElement___row
  :: SX -> Int -> IO Int
casADi__Matrix_CasADi__SXElement___row x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_CasADi__SXElement___row x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL] 
-}
sx_row :: SXClass a => a -> Int -> IO Int
sx_row x = casADi__Matrix_CasADi__SXElement___row (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___colind" c_CasADi__Matrix_CasADi__SXElement___colind
  :: Ptr SX' -> CInt -> IO CInt
casADi__Matrix_CasADi__SXElement___colind
  :: SX -> Int -> IO Int
casADi__Matrix_CasADi__SXElement___colind x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_CasADi__SXElement___colind x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL] 
-}
sx_colind :: SXClass a => a -> Int -> IO Int
sx_colind x = casADi__Matrix_CasADi__SXElement___colind (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___clear" c_CasADi__Matrix_CasADi__SXElement___clear
  :: Ptr SX' -> IO ()
casADi__Matrix_CasADi__SXElement___clear
  :: SX -> IO ()
casADi__Matrix_CasADi__SXElement___clear x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SXElement___clear x0' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL] 
-}
sx_clear :: SXClass a => a -> IO ()
sx_clear x = casADi__Matrix_CasADi__SXElement___clear (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___resize" c_CasADi__Matrix_CasADi__SXElement___resize
  :: Ptr SX' -> CInt -> CInt -> IO ()
casADi__Matrix_CasADi__SXElement___resize
  :: SX -> Int -> Int -> IO ()
casADi__Matrix_CasADi__SXElement___resize x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_CasADi__SXElement___resize x0' x1' x2' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL] 
-}
sx_resize :: SXClass a => a -> Int -> Int -> IO ()
sx_resize x = casADi__Matrix_CasADi__SXElement___resize (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___reserve" c_CasADi__Matrix_CasADi__SXElement___reserve
  :: Ptr SX' -> CInt -> IO ()
casADi__Matrix_CasADi__SXElement___reserve
  :: SX -> Int -> IO ()
casADi__Matrix_CasADi__SXElement___reserve x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_CasADi__SXElement___reserve x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL] 
-}
sx_reserve :: SXClass a => a -> Int -> IO ()
sx_reserve x = casADi__Matrix_CasADi__SXElement___reserve (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___reserve_TIC" c_CasADi__Matrix_CasADi__SXElement___reserve_TIC
  :: Ptr SX' -> CInt -> CInt -> IO ()
casADi__Matrix_CasADi__SXElement___reserve'
  :: SX -> Int -> Int -> IO ()
casADi__Matrix_CasADi__SXElement___reserve' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_CasADi__SXElement___reserve_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
sx_reserve' :: SXClass a => a -> Int -> Int -> IO ()
sx_reserve' x = casADi__Matrix_CasADi__SXElement___reserve' (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___erase" c_CasADi__Matrix_CasADi__SXElement___erase
  :: Ptr SX' -> Ptr (CppVec CInt) -> Ptr (CppVec CInt) -> IO ()
casADi__Matrix_CasADi__SXElement___erase
  :: SX -> Vector Int -> Vector Int -> IO ()
casADi__Matrix_CasADi__SXElement___erase x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_CasADi__SXElement___erase x0' x1' x2' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Erase a submatrix
>Erase rows and/or columns of a matrix.
-}
sx_erase :: SXClass a => a -> Vector Int -> Vector Int -> IO ()
sx_erase x = casADi__Matrix_CasADi__SXElement___erase (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___remove" c_CasADi__Matrix_CasADi__SXElement___remove
  :: Ptr SX' -> Ptr (CppVec CInt) -> Ptr (CppVec CInt) -> IO ()
casADi__Matrix_CasADi__SXElement___remove
  :: SX -> Vector Int -> Vector Int -> IO ()
casADi__Matrix_CasADi__SXElement___remove x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_CasADi__SXElement___remove x0' x1' x2' >>= wrapReturn

-- classy wrapper
{-|
> [INTERNAL]  Remove cols or
>rows Rremove/delete rows and/or columns of a matrix.
-}
sx_remove :: SXClass a => a -> Vector Int -> Vector Int -> IO ()
sx_remove x = casADi__Matrix_CasADi__SXElement___remove (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___enlarge" c_CasADi__Matrix_CasADi__SXElement___enlarge
  :: Ptr SX' -> CInt -> CInt -> Ptr (CppVec CInt) -> Ptr (CppVec CInt) -> IO ()
casADi__Matrix_CasADi__SXElement___enlarge
  :: SX -> Int -> Int -> Vector Int -> Vector Int -> IO ()
casADi__Matrix_CasADi__SXElement___enlarge x0 x1 x2 x3 x4 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  c_CasADi__Matrix_CasADi__SXElement___enlarge x0' x1' x2' x3' x4' >>= wrapReturn

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


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___data" c_CasADi__Matrix_CasADi__SXElement___data
  :: Ptr SX' -> IO (Ptr (CppVec (Ptr SXElement')))
casADi__Matrix_CasADi__SXElement___data
  :: SX -> IO (Vector SXElement)
casADi__Matrix_CasADi__SXElement___data x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SXElement___data x0' >>= wrapReturn

-- classy wrapper
{-|
>>  std::vector< DataType > & CasADi::Matrix< DataType >::data()
>------------------------------------------------------------------------
>[INTERNAL] 
>Access the non-zero elements.
>
>>  const std::vector< DataType > & CasADi::Matrix< DataType >::data() const 
>------------------------------------------------------------------------
>[INTERNAL] 
>Const access the non-zero elements.
-}
sx_data :: SXClass a => a -> IO (Vector SXElement)
sx_data x = casADi__Matrix_CasADi__SXElement___data (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___sparsityRef" c_CasADi__Matrix_CasADi__SXElement___sparsityRef
  :: Ptr SX' -> IO (Ptr Sparsity')
casADi__Matrix_CasADi__SXElement___sparsityRef
  :: SX -> IO Sparsity
casADi__Matrix_CasADi__SXElement___sparsityRef x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SXElement___sparsityRef x0' >>= wrapReturn

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


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___set" c_CasADi__Matrix_CasADi__SXElement___set
  :: Ptr SX' -> Ptr SXElement' -> CInt -> IO ()
casADi__Matrix_CasADi__SXElement___set
  :: SX -> SXElement -> SparsityType -> IO ()
casADi__Matrix_CasADi__SXElement___set x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_CasADi__SXElement___set x0' x1' x2' >>= wrapReturn

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


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___set_TIC" c_CasADi__Matrix_CasADi__SXElement___set_TIC
  :: Ptr SX' -> Ptr SXElement' -> IO ()
casADi__Matrix_CasADi__SXElement___set'
  :: SX -> SXElement -> IO ()
casADi__Matrix_CasADi__SXElement___set' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_CasADi__SXElement___set_TIC x0' x1' >>= wrapReturn

-- classy wrapper
sx_set' :: SXClass a => a -> SXElement -> IO ()
sx_set' x = casADi__Matrix_CasADi__SXElement___set' (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___get" c_CasADi__Matrix_CasADi__SXElement___get
  :: Ptr SX' -> Ptr SXElement' -> CInt -> IO ()
casADi__Matrix_CasADi__SXElement___get
  :: SX -> SXElement -> SparsityType -> IO ()
casADi__Matrix_CasADi__SXElement___get x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_CasADi__SXElement___get x0' x1' x2' >>= wrapReturn

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


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___get_TIC" c_CasADi__Matrix_CasADi__SXElement___get_TIC
  :: Ptr SX' -> Ptr SXElement' -> IO ()
casADi__Matrix_CasADi__SXElement___get'
  :: SX -> SXElement -> IO ()
casADi__Matrix_CasADi__SXElement___get' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_CasADi__SXElement___get_TIC x0' x1' >>= wrapReturn

-- classy wrapper
sx_get' :: SXClass a => a -> SXElement -> IO ()
sx_get' x = casADi__Matrix_CasADi__SXElement___get' (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___set_TIC_TIC" c_CasADi__Matrix_CasADi__SXElement___set_TIC_TIC
  :: Ptr SX' -> Ptr (CppVec (Ptr SXElement')) -> CInt -> IO ()
casADi__Matrix_CasADi__SXElement___set''
  :: SX -> Vector SXElement -> SparsityType -> IO ()
casADi__Matrix_CasADi__SXElement___set'' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_CasADi__SXElement___set_TIC_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
sx_set'' :: SXClass a => a -> Vector SXElement -> SparsityType -> IO ()
sx_set'' x = casADi__Matrix_CasADi__SXElement___set'' (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___set_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SXElement___set_TIC_TIC_TIC
  :: Ptr SX' -> Ptr (CppVec (Ptr SXElement')) -> IO ()
casADi__Matrix_CasADi__SXElement___set'''
  :: SX -> Vector SXElement -> IO ()
casADi__Matrix_CasADi__SXElement___set''' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_CasADi__SXElement___set_TIC_TIC_TIC x0' x1' >>= wrapReturn

-- classy wrapper
sx_set''' :: SXClass a => a -> Vector SXElement -> IO ()
sx_set''' x = casADi__Matrix_CasADi__SXElement___set''' (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___get_TIC_TIC" c_CasADi__Matrix_CasADi__SXElement___get_TIC_TIC
  :: Ptr SX' -> Ptr (CppVec (Ptr SXElement')) -> CInt -> IO ()
casADi__Matrix_CasADi__SXElement___get''
  :: SX -> Vector SXElement -> SparsityType -> IO ()
casADi__Matrix_CasADi__SXElement___get'' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_CasADi__SXElement___get_TIC_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
sx_get'' :: SXClass a => a -> Vector SXElement -> SparsityType -> IO ()
sx_get'' x = casADi__Matrix_CasADi__SXElement___get'' (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___get_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SXElement___get_TIC_TIC_TIC
  :: Ptr SX' -> Ptr (CppVec (Ptr SXElement')) -> IO ()
casADi__Matrix_CasADi__SXElement___get'''
  :: SX -> Vector SXElement -> IO ()
casADi__Matrix_CasADi__SXElement___get''' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_CasADi__SXElement___get_TIC_TIC_TIC x0' x1' >>= wrapReturn

-- classy wrapper
sx_get''' :: SXClass a => a -> Vector SXElement -> IO ()
sx_get''' x = casADi__Matrix_CasADi__SXElement___get''' (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___set_TIC_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SXElement___set_TIC_TIC_TIC_TIC
  :: Ptr SX' -> Ptr SX' -> CInt -> IO ()
casADi__Matrix_CasADi__SXElement___set''''
  :: SX -> SX -> SparsityType -> IO ()
casADi__Matrix_CasADi__SXElement___set'''' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_CasADi__SXElement___set_TIC_TIC_TIC_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
sx_set'''' :: SXClass a => a -> SX -> SparsityType -> IO ()
sx_set'''' x = casADi__Matrix_CasADi__SXElement___set'''' (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___set_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SXElement___set_TIC_TIC_TIC_TIC_TIC
  :: Ptr SX' -> Ptr SX' -> IO ()
casADi__Matrix_CasADi__SXElement___set'''''
  :: SX -> SX -> IO ()
casADi__Matrix_CasADi__SXElement___set''''' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_CasADi__SXElement___set_TIC_TIC_TIC_TIC_TIC x0' x1' >>= wrapReturn

-- classy wrapper
sx_set''''' :: SXClass a => a -> SX -> IO ()
sx_set''''' x = casADi__Matrix_CasADi__SXElement___set''''' (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___get_TIC_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SXElement___get_TIC_TIC_TIC_TIC
  :: Ptr SX' -> Ptr SX' -> CInt -> IO ()
casADi__Matrix_CasADi__SXElement___get''''
  :: SX -> SX -> SparsityType -> IO ()
casADi__Matrix_CasADi__SXElement___get'''' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_CasADi__SXElement___get_TIC_TIC_TIC_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
sx_get'''' :: SXClass a => a -> SX -> SparsityType -> IO ()
sx_get'''' x = casADi__Matrix_CasADi__SXElement___get'''' (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___get_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SXElement___get_TIC_TIC_TIC_TIC_TIC
  :: Ptr SX' -> Ptr SX' -> IO ()
casADi__Matrix_CasADi__SXElement___get'''''
  :: SX -> SX -> IO ()
casADi__Matrix_CasADi__SXElement___get''''' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_CasADi__SXElement___get_TIC_TIC_TIC_TIC_TIC x0' x1' >>= wrapReturn

-- classy wrapper
sx_get''''' :: SXClass a => a -> SX -> IO ()
sx_get''''' x = casADi__Matrix_CasADi__SXElement___get''''' (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___triplet" c_CasADi__Matrix_CasADi__SXElement___triplet
  :: Ptr (CppVec CInt) -> Ptr (CppVec CInt) -> Ptr (CppVec (Ptr SXElement')) -> IO (Ptr SX')
casADi__Matrix_CasADi__SXElement___triplet
  :: Vector Int -> Vector Int -> Vector SXElement -> IO SX
casADi__Matrix_CasADi__SXElement___triplet x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_CasADi__SXElement___triplet x0' x1' x2' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL] 
-}
sx_triplet :: Vector Int -> Vector Int -> Vector SXElement -> IO SX
sx_triplet = casADi__Matrix_CasADi__SXElement___triplet


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___triplet_TIC" c_CasADi__Matrix_CasADi__SXElement___triplet_TIC
  :: Ptr (CppVec CInt) -> Ptr (CppVec CInt) -> Ptr (CppVec (Ptr SXElement')) -> CInt -> CInt -> IO (Ptr SX')
casADi__Matrix_CasADi__SXElement___triplet'
  :: Vector Int -> Vector Int -> Vector SXElement -> Int -> Int -> IO SX
casADi__Matrix_CasADi__SXElement___triplet' x0 x1 x2 x3 x4 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  c_CasADi__Matrix_CasADi__SXElement___triplet_TIC x0' x1' x2' x3' x4' >>= wrapReturn

-- classy wrapper
sx_triplet' :: Vector Int -> Vector Int -> Vector SXElement -> Int -> Int -> IO SX
sx_triplet' = casADi__Matrix_CasADi__SXElement___triplet'


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___inf" c_CasADi__Matrix_CasADi__SXElement___inf
  :: Ptr Sparsity' -> IO (Ptr SX')
casADi__Matrix_CasADi__SXElement___inf
  :: Sparsity -> IO SX
casADi__Matrix_CasADi__SXElement___inf x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SXElement___inf x0' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  create a matrix with
>all inf
-}
sx_inf :: Sparsity -> IO SX
sx_inf = casADi__Matrix_CasADi__SXElement___inf


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___inf_TIC" c_CasADi__Matrix_CasADi__SXElement___inf_TIC
  :: CInt -> CInt -> IO (Ptr SX')
casADi__Matrix_CasADi__SXElement___inf'
  :: Int -> Int -> IO SX
casADi__Matrix_CasADi__SXElement___inf' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_CasADi__SXElement___inf_TIC x0' x1' >>= wrapReturn

-- classy wrapper
sx_inf' :: Int -> Int -> IO SX
sx_inf' = casADi__Matrix_CasADi__SXElement___inf'


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___inf_TIC_TIC" c_CasADi__Matrix_CasADi__SXElement___inf_TIC_TIC
  :: CInt -> IO (Ptr SX')
casADi__Matrix_CasADi__SXElement___inf''
  :: Int -> IO SX
casADi__Matrix_CasADi__SXElement___inf'' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SXElement___inf_TIC_TIC x0' >>= wrapReturn

-- classy wrapper
sx_inf'' :: Int -> IO SX
sx_inf'' = casADi__Matrix_CasADi__SXElement___inf''


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___inf_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SXElement___inf_TIC_TIC_TIC
  :: IO (Ptr SX')
casADi__Matrix_CasADi__SXElement___inf'''
  :: IO SX
casADi__Matrix_CasADi__SXElement___inf'''  =
  c_CasADi__Matrix_CasADi__SXElement___inf_TIC_TIC_TIC  >>= wrapReturn

-- classy wrapper
sx_inf''' :: IO SX
sx_inf''' = casADi__Matrix_CasADi__SXElement___inf'''


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___nan" c_CasADi__Matrix_CasADi__SXElement___nan
  :: Ptr Sparsity' -> IO (Ptr SX')
casADi__Matrix_CasADi__SXElement___nan
  :: Sparsity -> IO SX
casADi__Matrix_CasADi__SXElement___nan x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SXElement___nan x0' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  create a matrix with
>all nan
-}
sx_nan :: Sparsity -> IO SX
sx_nan = casADi__Matrix_CasADi__SXElement___nan


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___nan_TIC" c_CasADi__Matrix_CasADi__SXElement___nan_TIC
  :: CInt -> CInt -> IO (Ptr SX')
casADi__Matrix_CasADi__SXElement___nan'
  :: Int -> Int -> IO SX
casADi__Matrix_CasADi__SXElement___nan' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_CasADi__SXElement___nan_TIC x0' x1' >>= wrapReturn

-- classy wrapper
sx_nan' :: Int -> Int -> IO SX
sx_nan' = casADi__Matrix_CasADi__SXElement___nan'


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___nan_TIC_TIC" c_CasADi__Matrix_CasADi__SXElement___nan_TIC_TIC
  :: CInt -> IO (Ptr SX')
casADi__Matrix_CasADi__SXElement___nan''
  :: Int -> IO SX
casADi__Matrix_CasADi__SXElement___nan'' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SXElement___nan_TIC_TIC x0' >>= wrapReturn

-- classy wrapper
sx_nan'' :: Int -> IO SX
sx_nan'' = casADi__Matrix_CasADi__SXElement___nan''


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___nan_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SXElement___nan_TIC_TIC_TIC
  :: IO (Ptr SX')
casADi__Matrix_CasADi__SXElement___nan'''
  :: IO SX
casADi__Matrix_CasADi__SXElement___nan'''  =
  c_CasADi__Matrix_CasADi__SXElement___nan_TIC_TIC_TIC  >>= wrapReturn

-- classy wrapper
sx_nan''' :: IO SX
sx_nan''' = casADi__Matrix_CasADi__SXElement___nan'''


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___repmat" c_CasADi__Matrix_CasADi__SXElement___repmat
  :: Ptr SXElement' -> Ptr Sparsity' -> IO (Ptr SX')
casADi__Matrix_CasADi__SXElement___repmat
  :: SXElement -> Sparsity -> IO SX
casADi__Matrix_CasADi__SXElement___repmat x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_CasADi__SXElement___repmat x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  create a matrix
>by repeating an existing matrix
-}
sx_repmat :: SXElement -> Sparsity -> IO SX
sx_repmat = casADi__Matrix_CasADi__SXElement___repmat


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___repmat_TIC" c_CasADi__Matrix_CasADi__SXElement___repmat_TIC
  :: Ptr SX' -> Ptr Sparsity' -> IO (Ptr SX')
casADi__Matrix_CasADi__SXElement___repmat'
  :: SX -> Sparsity -> IO SX
casADi__Matrix_CasADi__SXElement___repmat' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_CasADi__SXElement___repmat_TIC x0' x1' >>= wrapReturn

-- classy wrapper
sx_repmat' :: SX -> Sparsity -> IO SX
sx_repmat' = casADi__Matrix_CasADi__SXElement___repmat'


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___repmat_TIC_TIC" c_CasADi__Matrix_CasADi__SXElement___repmat_TIC_TIC
  :: Ptr SX' -> CInt -> CInt -> IO (Ptr SX')
casADi__Matrix_CasADi__SXElement___repmat''
  :: SX -> Int -> Int -> IO SX
casADi__Matrix_CasADi__SXElement___repmat'' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_CasADi__SXElement___repmat_TIC_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
sx_repmat'' :: SX -> Int -> Int -> IO SX
sx_repmat'' = casADi__Matrix_CasADi__SXElement___repmat''


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___repmat_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SXElement___repmat_TIC_TIC_TIC
  :: Ptr SX' -> CInt -> IO (Ptr SX')
casADi__Matrix_CasADi__SXElement___repmat'''
  :: SX -> Int -> IO SX
casADi__Matrix_CasADi__SXElement___repmat''' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_CasADi__SXElement___repmat_TIC_TIC_TIC x0' x1' >>= wrapReturn

-- classy wrapper
sx_repmat''' :: SX -> Int -> IO SX
sx_repmat''' = casADi__Matrix_CasADi__SXElement___repmat'''


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___eye" c_CasADi__Matrix_CasADi__SXElement___eye
  :: CInt -> IO (Ptr SX')
casADi__Matrix_CasADi__SXElement___eye
  :: Int -> IO SX
casADi__Matrix_CasADi__SXElement___eye x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SXElement___eye x0' >>= wrapReturn

-- classy wrapper
sx_eye :: Int -> IO SX
sx_eye = casADi__Matrix_CasADi__SXElement___eye


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___isRegular" c_CasADi__Matrix_CasADi__SXElement___isRegular
  :: Ptr SX' -> IO CInt
casADi__Matrix_CasADi__SXElement___isRegular
  :: SX -> IO Bool
casADi__Matrix_CasADi__SXElement___isRegular x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SXElement___isRegular x0' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Checks if
>expression does not contain NaN or Inf.
-}
sx_isRegular :: SXClass a => a -> IO Bool
sx_isRegular x = casADi__Matrix_CasADi__SXElement___isRegular (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___isSmooth" c_CasADi__Matrix_CasADi__SXElement___isSmooth
  :: Ptr SX' -> IO CInt
casADi__Matrix_CasADi__SXElement___isSmooth
  :: SX -> IO Bool
casADi__Matrix_CasADi__SXElement___isSmooth x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SXElement___isSmooth x0' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Check if
>smooth.
-}
sx_isSmooth :: SXClass a => a -> IO Bool
sx_isSmooth x = casADi__Matrix_CasADi__SXElement___isSmooth (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___isSymbolic" c_CasADi__Matrix_CasADi__SXElement___isSymbolic
  :: Ptr SX' -> IO CInt
casADi__Matrix_CasADi__SXElement___isSymbolic
  :: SX -> IO Bool
casADi__Matrix_CasADi__SXElement___isSymbolic x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SXElement___isSymbolic x0' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Check if
>symbolic (Dense) Sparse matrices invariable return false.
-}
sx_isSymbolic :: SXClass a => a -> IO Bool
sx_isSymbolic x = casADi__Matrix_CasADi__SXElement___isSymbolic (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___isSymbolicSparse" c_CasADi__Matrix_CasADi__SXElement___isSymbolicSparse
  :: Ptr SX' -> IO CInt
casADi__Matrix_CasADi__SXElement___isSymbolicSparse
  :: SX -> IO Bool
casADi__Matrix_CasADi__SXElement___isSymbolicSparse x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SXElement___isSymbolicSparse x0' >>= wrapReturn

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


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___isConstant" c_CasADi__Matrix_CasADi__SXElement___isConstant
  :: Ptr SX' -> IO CInt
casADi__Matrix_CasADi__SXElement___isConstant
  :: SX -> IO Bool
casADi__Matrix_CasADi__SXElement___isConstant x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SXElement___isConstant x0' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Check if the
>matrix is constant (note that false negative answers are possible)
-}
sx_isConstant :: SXClass a => a -> IO Bool
sx_isConstant x = casADi__Matrix_CasADi__SXElement___isConstant (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___isInteger" c_CasADi__Matrix_CasADi__SXElement___isInteger
  :: Ptr SX' -> IO CInt
casADi__Matrix_CasADi__SXElement___isInteger
  :: SX -> IO Bool
casADi__Matrix_CasADi__SXElement___isInteger x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SXElement___isInteger x0' >>= wrapReturn

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


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___isZero" c_CasADi__Matrix_CasADi__SXElement___isZero
  :: Ptr SX' -> IO CInt
casADi__Matrix_CasADi__SXElement___isZero
  :: SX -> IO Bool
casADi__Matrix_CasADi__SXElement___isZero x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SXElement___isZero x0' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  check if the
>matrix is 0 (note that false negative answers are possible)
-}
sx_isZero :: SXClass a => a -> IO Bool
sx_isZero x = casADi__Matrix_CasADi__SXElement___isZero (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___isOne" c_CasADi__Matrix_CasADi__SXElement___isOne
  :: Ptr SX' -> IO CInt
casADi__Matrix_CasADi__SXElement___isOne
  :: SX -> IO Bool
casADi__Matrix_CasADi__SXElement___isOne x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SXElement___isOne x0' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  check if the
>matrix is 1 (note that false negative answers are possible)
-}
sx_isOne :: SXClass a => a -> IO Bool
sx_isOne x = casADi__Matrix_CasADi__SXElement___isOne (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___isMinusOne" c_CasADi__Matrix_CasADi__SXElement___isMinusOne
  :: Ptr SX' -> IO CInt
casADi__Matrix_CasADi__SXElement___isMinusOne
  :: SX -> IO Bool
casADi__Matrix_CasADi__SXElement___isMinusOne x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SXElement___isMinusOne x0' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  check if the
>matrix is -1 (note that false negative answers are possible)
-}
sx_isMinusOne :: SXClass a => a -> IO Bool
sx_isMinusOne x = casADi__Matrix_CasADi__SXElement___isMinusOne (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___isIdentity" c_CasADi__Matrix_CasADi__SXElement___isIdentity
  :: Ptr SX' -> IO CInt
casADi__Matrix_CasADi__SXElement___isIdentity
  :: SX -> IO Bool
casADi__Matrix_CasADi__SXElement___isIdentity x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SXElement___isIdentity x0' >>= wrapReturn

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


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___isEqual" c_CasADi__Matrix_CasADi__SXElement___isEqual
  :: Ptr SX' -> Ptr SX' -> IO CInt
casADi__Matrix_CasADi__SXElement___isEqual
  :: SX -> SX -> IO Bool
casADi__Matrix_CasADi__SXElement___isEqual x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_CasADi__SXElement___isEqual x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Check if two
>expressions are equal May give false negatives.
>
>Note: does not work when CasadiOptions.setSimplificationOnTheFly(False) was
>called
-}
sx_isEqual :: SXClass a => a -> SX -> IO Bool
sx_isEqual x = casADi__Matrix_CasADi__SXElement___isEqual (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___hasNonStructuralZeros" c_CasADi__Matrix_CasADi__SXElement___hasNonStructuralZeros
  :: Ptr SX' -> IO CInt
casADi__Matrix_CasADi__SXElement___hasNonStructuralZeros
  :: SX -> IO Bool
casADi__Matrix_CasADi__SXElement___hasNonStructuralZeros x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SXElement___hasNonStructuralZeros x0' >>= wrapReturn

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


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___getValue" c_CasADi__Matrix_CasADi__SXElement___getValue
  :: Ptr SX' -> IO CDouble
casADi__Matrix_CasADi__SXElement___getValue
  :: SX -> IO Double
casADi__Matrix_CasADi__SXElement___getValue x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SXElement___getValue x0' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Get double
>value (only if constant)
-}
sx_getValue :: SXClass a => a -> IO Double
sx_getValue x = casADi__Matrix_CasADi__SXElement___getValue (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___getName" c_CasADi__Matrix_CasADi__SXElement___getName
  :: Ptr SX' -> IO (Ptr StdString')
casADi__Matrix_CasADi__SXElement___getName
  :: SX -> IO String
casADi__Matrix_CasADi__SXElement___getName x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SXElement___getName x0' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Get name (only
>if symbolic scalar)
-}
sx_getName :: SXClass a => a -> IO String
sx_getName x = casADi__Matrix_CasADi__SXElement___getName (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___setPrecision" c_CasADi__Matrix_CasADi__SXElement___setPrecision
  :: CInt -> IO ()
casADi__Matrix_CasADi__SXElement___setPrecision
  :: Int -> IO ()
casADi__Matrix_CasADi__SXElement___setPrecision x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SXElement___setPrecision x0' >>= wrapReturn

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


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___setWidth" c_CasADi__Matrix_CasADi__SXElement___setWidth
  :: CInt -> IO ()
casADi__Matrix_CasADi__SXElement___setWidth
  :: Int -> IO ()
casADi__Matrix_CasADi__SXElement___setWidth x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SXElement___setWidth x0' >>= wrapReturn

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


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___setScientific" c_CasADi__Matrix_CasADi__SXElement___setScientific
  :: CInt -> IO ()
casADi__Matrix_CasADi__SXElement___setScientific
  :: Bool -> IO ()
casADi__Matrix_CasADi__SXElement___setScientific x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SXElement___setScientific x0' >>= wrapReturn

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


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___SX" c_CasADi__Matrix_CasADi__SXElement___SX
  :: IO (Ptr SX')
casADi__Matrix_CasADi__SXElement___SX
  :: IO SX
casADi__Matrix_CasADi__SXElement___SX  =
  c_CasADi__Matrix_CasADi__SXElement___SX  >>= wrapReturn

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


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___SX_TIC" c_CasADi__Matrix_CasADi__SXElement___SX_TIC
  :: Ptr SX' -> IO (Ptr SX')
casADi__Matrix_CasADi__SXElement___SX'
  :: SX -> IO SX
casADi__Matrix_CasADi__SXElement___SX' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SXElement___SX_TIC x0' >>= wrapReturn

-- classy wrapper
sx' :: SX -> IO SX
sx' = casADi__Matrix_CasADi__SXElement___SX'


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC" c_CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC
  :: Ptr (CppVec (Ptr (CppVec (Ptr SXElement')))) -> IO (Ptr SX')
casADi__Matrix_CasADi__SXElement___SX''
  :: Vector (Vector SXElement) -> IO SX
casADi__Matrix_CasADi__SXElement___SX'' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC x0' >>= wrapReturn

-- classy wrapper
sx'' :: Vector (Vector SXElement) -> IO SX
sx'' = casADi__Matrix_CasADi__SXElement___SX''


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC
  :: Ptr Sparsity' -> Ptr SXElement' -> IO (Ptr SX')
casADi__Matrix_CasADi__SXElement___SX'''
  :: Sparsity -> SXElement -> IO SX
casADi__Matrix_CasADi__SXElement___SX''' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC x0' x1' >>= wrapReturn

-- classy wrapper
sx''' :: Sparsity -> SXElement -> IO SX
sx''' = casADi__Matrix_CasADi__SXElement___SX'''


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC
  :: Ptr Sparsity' -> IO (Ptr SX')
casADi__Matrix_CasADi__SXElement___SX''''
  :: Sparsity -> IO SX
casADi__Matrix_CasADi__SXElement___SX'''' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC x0' >>= wrapReturn

-- classy wrapper
sx'''' :: Sparsity -> IO SX
sx'''' = casADi__Matrix_CasADi__SXElement___SX''''


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC_TIC
  :: Ptr Sparsity' -> Ptr (CppVec (Ptr SXElement')) -> IO (Ptr SX')
casADi__Matrix_CasADi__SXElement___SX'''''
  :: Sparsity -> Vector SXElement -> IO SX
casADi__Matrix_CasADi__SXElement___SX''''' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC_TIC x0' x1' >>= wrapReturn

-- classy wrapper
sx''''' :: Sparsity -> Vector SXElement -> IO SX
sx''''' = casADi__Matrix_CasADi__SXElement___SX'''''


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC_TIC_TIC
  :: CDouble -> IO (Ptr SX')
casADi__Matrix_CasADi__SXElement___SX''''''
  :: Double -> IO SX
casADi__Matrix_CasADi__SXElement___SX'''''' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC_TIC_TIC x0' >>= wrapReturn

-- classy wrapper
sx'''''' :: Double -> IO SX
sx'''''' = casADi__Matrix_CasADi__SXElement___SX''''''


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC_TIC_TIC_TIC
  :: Ptr (CppVec (Ptr SXElement')) -> IO (Ptr SX')
casADi__Matrix_CasADi__SXElement___SX'''''''
  :: Vector SXElement -> IO SX
casADi__Matrix_CasADi__SXElement___SX''''''' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' >>= wrapReturn

-- classy wrapper
sx''''''' :: Vector SXElement -> IO SX
sx''''''' = casADi__Matrix_CasADi__SXElement___SX'''''''


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC
  :: Ptr (CppVec (Ptr SXElement')) -> CInt -> CInt -> IO (Ptr SX')
casADi__Matrix_CasADi__SXElement___SX''''''''
  :: Vector SXElement -> Int -> Int -> IO SX
casADi__Matrix_CasADi__SXElement___SX'''''''' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
sx'''''''' :: Vector SXElement -> Int -> Int -> IO SX
sx'''''''' = casADi__Matrix_CasADi__SXElement___SX''''''''


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC
  :: Ptr IMatrix' -> IO (Ptr SX')
casADi__Matrix_CasADi__SXElement___SX'''''''''
  :: IMatrix -> IO SX
casADi__Matrix_CasADi__SXElement___SX''''''''' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' >>= wrapReturn

-- classy wrapper
sx''''''''' :: IMatrix -> IO SX
sx''''''''' = casADi__Matrix_CasADi__SXElement___SX'''''''''


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC
  :: Ptr (CppVec CInt) -> IO (Ptr SX')
casADi__Matrix_CasADi__SXElement___SX''''''''''
  :: Vector Int -> IO SX
casADi__Matrix_CasADi__SXElement___SX'''''''''' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' >>= wrapReturn

-- classy wrapper
sx'''''''''' :: Vector Int -> IO SX
sx'''''''''' = casADi__Matrix_CasADi__SXElement___SX''''''''''


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC
  :: Ptr (CppVec CInt) -> CInt -> CInt -> IO (Ptr SX')
casADi__Matrix_CasADi__SXElement___SX'''''''''''
  :: Vector Int -> Int -> Int -> IO SX
casADi__Matrix_CasADi__SXElement___SX''''''''''' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
sx''''''''''' :: Vector Int -> Int -> Int -> IO SX
sx''''''''''' = casADi__Matrix_CasADi__SXElement___SX'''''''''''


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC
  :: Ptr DMatrix' -> IO (Ptr SX')
casADi__Matrix_CasADi__SXElement___SX''''''''''''
  :: DMatrix -> IO SX
casADi__Matrix_CasADi__SXElement___SX'''''''''''' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' >>= wrapReturn

-- classy wrapper
sx'''''''''''' :: DMatrix -> IO SX
sx'''''''''''' = casADi__Matrix_CasADi__SXElement___SX''''''''''''


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC
  :: Ptr (CppVec CDouble) -> IO (Ptr SX')
casADi__Matrix_CasADi__SXElement___SX'''''''''''''
  :: Vector Double -> IO SX
casADi__Matrix_CasADi__SXElement___SX''''''''''''' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' >>= wrapReturn

-- classy wrapper
sx''''''''''''' :: Vector Double -> IO SX
sx''''''''''''' = casADi__Matrix_CasADi__SXElement___SX'''''''''''''


-- direct wrapper
foreign import ccall unsafe "CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC
  :: Ptr (CppVec CDouble) -> CInt -> CInt -> IO (Ptr SX')
casADi__Matrix_CasADi__SXElement___SX''''''''''''''
  :: Vector Double -> Int -> Int -> IO SX
casADi__Matrix_CasADi__SXElement___SX'''''''''''''' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__Matrix_CasADi__SXElement___SX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
sx'''''''''''''' :: Vector Double -> Int -> Int -> IO SX
sx'''''''''''''' = casADi__Matrix_CasADi__SXElement___SX''''''''''''''