casadi-bindings-1.9.0.0: Casadi/Wrappers/Classes/MX.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.MX
       (
         MX,
         MXClass(..),
         mx,
         mx',
         mx'',
         mx''',
         mx'''',
         mx''''',
         mx'''''',
         mx''''''',
         mx'''''''',
         mx___add__,
         mx___constpow__,
         mx___copysign__,
         mx___div__,
         mx___eq__,
         mx___hash__,
         mx___le__,
         mx___lt__,
         mx___mpower__,
         mx___mrdivide__,
         mx___mul__,
         mx___ne__,
         mx___nonzero__,
         mx___pow__,
         mx___sub__,
         mx___truediv__,
         mx_addToSum,
         mx_append,
         mx_appendColumns,
         mx_arccos,
         mx_arccosh,
         mx_arcsin,
         mx_arcsinh,
         mx_arctan,
         mx_arctan2,
         mx_arctanh,
         mx_attachAssert,
         mx_attachAssert',
         mx_binary,
         mx_ceil,
         mx_constpow,
         mx_cos,
         mx_cosh,
         mx_densify,
         mx_densify',
         mx_enlarge,
         mx_erase,
         mx_erf,
         mx_erfinv,
         mx_exp,
         mx_eye,
         mx_fabs,
         mx_floor,
         mx_fmax,
         mx_fmin,
         mx_getDep,
         mx_getDep',
         mx_getEqualityCheckingDepth,
         mx_getEvaluationOutput,
         mx_getFunction,
         mx_getMatrixValue,
         mx_getMaxNumCallsInPrint,
         mx_getNZ,
         mx_getNZ',
         mx_getNZ'',
         mx_getNZ''',
         mx_getName,
         mx_getNdeps,
         mx_getNumOutputs,
         mx_getOp,
         mx_getOutput,
         mx_getOutput',
         mx_getTemp,
         mx_getValue,
         mx_if_else_zero,
         mx_indexed_assignment,
         mx_indexed_assignment',
         mx_indexed_assignment'',
         mx_indexed_assignment''',
         mx_indexed_assignment'''',
         mx_indexed_assignment''''',
         mx_indexed_assignment'''''',
         mx_indexed_assignment''''''',
         mx_indexed_assignment'''''''',
         mx_indexed_assignment''''''''',
         mx_indexed_one_based_assignment,
         mx_indexed_one_based_assignment',
         mx_indexed_zero_based_assignment,
         mx_indexed_zero_based_assignment',
         mx_indexed_zero_based_assignment'',
         mx_inf,
         mx_inf',
         mx_inf'',
         mx_inf''',
         mx_inner_prod,
         mx_isBinary,
         mx_isCommutative,
         mx_isConstant,
         mx_isEqual,
         mx_isEqual',
         mx_isEvaluation,
         mx_isEvaluationOutput,
         mx_isIdentity,
         mx_isMinusOne,
         mx_isMultiplication,
         mx_isNorm,
         mx_isOne,
         mx_isOperation,
         mx_isRegular,
         mx_isSymbolic,
         mx_isSymbolicSparse,
         mx_isTranspose,
         mx_isUnary,
         mx_isZero,
         mx_lift,
         mx_log,
         mx_log10,
         mx_logic_and,
         mx_logic_not,
         mx_logic_or,
         mx_mapping,
         mx_mul,
         mx_mul',
         mx_mul_full,
         mx_mul_full',
         mx_nan,
         mx_nan',
         mx_nan'',
         mx_nan''',
         mx_nz_indexed_assignment,
         mx_nz_indexed_assignment',
         mx_nz_indexed_one_based_assignment,
         mx_nz_indexed_zero_based_assignment,
         mx_operator_minus,
         mx_outer_prod,
         mx_printme,
         mx_repmat,
         mx_repmat',
         mx_repmat'',
         mx_setEqualityCheckingDepth,
         mx_setEqualityCheckingDepth',
         mx_setMaxNumCallsInPrint,
         mx_setMaxNumCallsInPrint',
         mx_setNZ,
         mx_setNZ',
         mx_setNZ'',
         mx_setNZ''',
         mx_setSparse,
         mx_setSparse',
         mx_setSub,
         mx_setSub',
         mx_setSub'',
         mx_setSub''',
         mx_setSub'''',
         mx_setSub''''',
         mx_setSub'''''',
         mx_setSub''''''',
         mx_setSub'''''''',
         mx_setSub''''''''',
         mx_setTemp,
         mx_sign,
         mx_sin,
         mx_sinh,
         mx_sparsityRef,
         mx_sqrt,
         mx_tan,
         mx_tanh,
         mx_trans,
         mx_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 MX where
  show = unsafePerformIO . printableObject_getDescription
-- direct wrapper
foreign import ccall unsafe "CasADi__MX____nonzero__" c_CasADi__MX____nonzero__
  :: Ptr MX' -> IO CInt
casADi__MX____nonzero__
  :: MX -> IO Bool
casADi__MX____nonzero__ x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__MX____nonzero__ x0' >>= wrapReturn

-- classy wrapper
{-|
>Returns the truth value of an MX expression.
-}
mx___nonzero__ :: MXClass a => a -> IO Bool
mx___nonzero__ x = casADi__MX____nonzero__ (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__nz_indexed_one_based_assignment" c_CasADi__MX__nz_indexed_one_based_assignment
  :: Ptr MX' -> CInt -> Ptr MX' -> IO ()
casADi__MX__nz_indexed_one_based_assignment
  :: MX -> Int -> MX -> IO ()
casADi__MX__nz_indexed_one_based_assignment x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__MX__nz_indexed_one_based_assignment x0' x1' x2' >>= wrapReturn

-- classy wrapper
{-|
>set a non-zero
-}
mx_nz_indexed_one_based_assignment :: MXClass a => a -> Int -> MX -> IO ()
mx_nz_indexed_one_based_assignment x = casADi__MX__nz_indexed_one_based_assignment (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__nz_indexed_zero_based_assignment" c_CasADi__MX__nz_indexed_zero_based_assignment
  :: Ptr MX' -> CInt -> Ptr MX' -> IO ()
casADi__MX__nz_indexed_zero_based_assignment
  :: MX -> Int -> MX -> IO ()
casADi__MX__nz_indexed_zero_based_assignment x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__MX__nz_indexed_zero_based_assignment x0' x1' x2' >>= wrapReturn

-- classy wrapper
{-|
>Indexing for interfaced languages.
>
>get a non-zero
-}
mx_nz_indexed_zero_based_assignment :: MXClass a => a -> Int -> MX -> IO ()
mx_nz_indexed_zero_based_assignment x = casADi__MX__nz_indexed_zero_based_assignment (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__nz_indexed_assignment" c_CasADi__MX__nz_indexed_assignment
  :: Ptr MX' -> Ptr IndexList' -> Ptr MX' -> IO ()
casADi__MX__nz_indexed_assignment
  :: MX -> IndexList -> MX -> IO ()
casADi__MX__nz_indexed_assignment x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__MX__nz_indexed_assignment x0' x1' x2' >>= wrapReturn

-- classy wrapper
{-|
>Indexing for interfaced languages.
>
>get a non-zero
-}
mx_nz_indexed_assignment :: MXClass a => a -> IndexList -> MX -> IO ()
mx_nz_indexed_assignment x = casADi__MX__nz_indexed_assignment (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__nz_indexed_assignment_TIC" c_CasADi__MX__nz_indexed_assignment_TIC
  :: Ptr MX' -> Ptr Slice' -> Ptr MX' -> IO ()
casADi__MX__nz_indexed_assignment'
  :: MX -> Slice -> MX -> IO ()
casADi__MX__nz_indexed_assignment' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__MX__nz_indexed_assignment_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
mx_nz_indexed_assignment' :: MXClass a => a -> Slice -> MX -> IO ()
mx_nz_indexed_assignment' x = casADi__MX__nz_indexed_assignment' (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__indexed_one_based_assignment" c_CasADi__MX__indexed_one_based_assignment
  :: Ptr MX' -> CInt -> CInt -> Ptr MX' -> IO ()
casADi__MX__indexed_one_based_assignment
  :: MX -> Int -> Int -> MX -> IO ()
casADi__MX__indexed_one_based_assignment x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  c_CasADi__MX__indexed_one_based_assignment x0' x1' x2' x3' >>= wrapReturn

-- classy wrapper
{-|
>>  void CasADi::MX::indexed_one_based_assignment(int rr, int cc, const MX &m)
>------------------------------------------------------------------------
>
>set a matrix element
-}
mx_indexed_one_based_assignment :: MXClass a => a -> Int -> Int -> MX -> IO ()
mx_indexed_one_based_assignment x = casADi__MX__indexed_one_based_assignment (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__indexed_zero_based_assignment" c_CasADi__MX__indexed_zero_based_assignment
  :: Ptr MX' -> CInt -> CInt -> Ptr MX' -> IO ()
casADi__MX__indexed_zero_based_assignment
  :: MX -> Int -> Int -> MX -> IO ()
casADi__MX__indexed_zero_based_assignment x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  c_CasADi__MX__indexed_zero_based_assignment x0' x1' x2' x3' >>= wrapReturn

-- classy wrapper
{-|
>>  void CasADi::MX::indexed_zero_based_assignment(int rr, int cc, const MX &m)
>
>>  void CasADi::MX::indexed_zero_based_assignment(const Matrix< int > &k, const MX &m)
>------------------------------------------------------------------------
>
>Indexing for interfaced languages.
>
>get a non-zero
-}
mx_indexed_zero_based_assignment :: MXClass a => a -> Int -> Int -> MX -> IO ()
mx_indexed_zero_based_assignment x = casADi__MX__indexed_zero_based_assignment (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__indexed_assignment" c_CasADi__MX__indexed_assignment
  :: Ptr MX' -> Ptr IndexList' -> Ptr IndexList' -> Ptr MX' -> IO ()
casADi__MX__indexed_assignment
  :: MX -> IndexList -> IndexList -> MX -> IO ()
casADi__MX__indexed_assignment x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  c_CasADi__MX__indexed_assignment x0' x1' x2' x3' >>= wrapReturn

-- classy wrapper
{-|
>>  void CasADi::MX::indexed_assignment(const IndexList &rr, const IndexList &cc, const MX &m)
>
>>  void CasADi::MX::indexed_assignment(const Slice &rr, const Slice &cc, const MX &m)
>
>>  void CasADi::MX::indexed_assignment(const Sparsity &sp, const MX &m)
>
>>  void CasADi::MX::indexed_assignment(const Matrix< int > &rr, const Slice &cc, const MX &m)
>
>>  void CasADi::MX::indexed_assignment(const Slice &rr, const Matrix< int > &cc, const MX &m)
>
>>  void CasADi::MX::indexed_assignment(const Matrix< int > &rr, const IndexList &cc, const MX &m)
>
>>  void CasADi::MX::indexed_assignment(const IndexList &rr, const Matrix< int > &cc, const MX &m)
>
>>  void CasADi::MX::indexed_assignment(const Matrix< int > &rr, const Matrix< int > &cc, const MX &m)
>------------------------------------------------------------------------
>
>Indexing for interfaced languages.
>
>get a non-zero
-}
mx_indexed_assignment :: MXClass a => a -> IndexList -> IndexList -> MX -> IO ()
mx_indexed_assignment x = casADi__MX__indexed_assignment (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__indexed_assignment_TIC" c_CasADi__MX__indexed_assignment_TIC
  :: Ptr MX' -> Ptr Slice' -> Ptr Slice' -> Ptr MX' -> IO ()
casADi__MX__indexed_assignment'
  :: MX -> Slice -> Slice -> MX -> IO ()
casADi__MX__indexed_assignment' x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  c_CasADi__MX__indexed_assignment_TIC x0' x1' x2' x3' >>= wrapReturn

-- classy wrapper
mx_indexed_assignment' :: MXClass a => a -> Slice -> Slice -> MX -> IO ()
mx_indexed_assignment' x = casADi__MX__indexed_assignment' (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__indexed_zero_based_assignment_TIC" c_CasADi__MX__indexed_zero_based_assignment_TIC
  :: Ptr MX' -> Ptr IMatrix' -> Ptr MX' -> IO ()
casADi__MX__indexed_zero_based_assignment'
  :: MX -> IMatrix -> MX -> IO ()
casADi__MX__indexed_zero_based_assignment' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__MX__indexed_zero_based_assignment_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
mx_indexed_zero_based_assignment' :: MXClass a => a -> IMatrix -> MX -> IO ()
mx_indexed_zero_based_assignment' x = casADi__MX__indexed_zero_based_assignment' (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__indexed_assignment_TIC_TIC" c_CasADi__MX__indexed_assignment_TIC_TIC
  :: Ptr MX' -> Ptr Sparsity' -> Ptr MX' -> IO ()
casADi__MX__indexed_assignment''
  :: MX -> Sparsity -> MX -> IO ()
casADi__MX__indexed_assignment'' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__MX__indexed_assignment_TIC_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
mx_indexed_assignment'' :: MXClass a => a -> Sparsity -> MX -> IO ()
mx_indexed_assignment'' x = casADi__MX__indexed_assignment'' (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__indexed_assignment_TIC_TIC_TIC" c_CasADi__MX__indexed_assignment_TIC_TIC_TIC
  :: Ptr MX' -> Ptr IMatrix' -> Ptr Slice' -> Ptr MX' -> IO ()
casADi__MX__indexed_assignment'''
  :: MX -> IMatrix -> Slice -> MX -> IO ()
casADi__MX__indexed_assignment''' x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  c_CasADi__MX__indexed_assignment_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn

-- classy wrapper
mx_indexed_assignment''' :: MXClass a => a -> IMatrix -> Slice -> MX -> IO ()
mx_indexed_assignment''' x = casADi__MX__indexed_assignment''' (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__indexed_assignment_TIC_TIC_TIC_TIC" c_CasADi__MX__indexed_assignment_TIC_TIC_TIC_TIC
  :: Ptr MX' -> Ptr Slice' -> Ptr IMatrix' -> Ptr MX' -> IO ()
casADi__MX__indexed_assignment''''
  :: MX -> Slice -> IMatrix -> MX -> IO ()
casADi__MX__indexed_assignment'''' x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  c_CasADi__MX__indexed_assignment_TIC_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn

-- classy wrapper
mx_indexed_assignment'''' :: MXClass a => a -> Slice -> IMatrix -> MX -> IO ()
mx_indexed_assignment'''' x = casADi__MX__indexed_assignment'''' (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__indexed_assignment_TIC_TIC_TIC_TIC_TIC" c_CasADi__MX__indexed_assignment_TIC_TIC_TIC_TIC_TIC
  :: Ptr MX' -> Ptr IMatrix' -> Ptr IndexList' -> Ptr MX' -> IO ()
casADi__MX__indexed_assignment'''''
  :: MX -> IMatrix -> IndexList -> MX -> IO ()
casADi__MX__indexed_assignment''''' x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  c_CasADi__MX__indexed_assignment_TIC_TIC_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn

-- classy wrapper
mx_indexed_assignment''''' :: MXClass a => a -> IMatrix -> IndexList -> MX -> IO ()
mx_indexed_assignment''''' x = casADi__MX__indexed_assignment''''' (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__MX__indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC
  :: Ptr MX' -> Ptr IndexList' -> Ptr IMatrix' -> Ptr MX' -> IO ()
casADi__MX__indexed_assignment''''''
  :: MX -> IndexList -> IMatrix -> MX -> IO ()
casADi__MX__indexed_assignment'''''' x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  c_CasADi__MX__indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn

-- classy wrapper
mx_indexed_assignment'''''' :: MXClass a => a -> IndexList -> IMatrix -> MX -> IO ()
mx_indexed_assignment'''''' x = casADi__MX__indexed_assignment'''''' (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__MX__indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC
  :: Ptr MX' -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr MX' -> IO ()
casADi__MX__indexed_assignment'''''''
  :: MX -> IMatrix -> IMatrix -> MX -> IO ()
casADi__MX__indexed_assignment''''''' x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  c_CasADi__MX__indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn

-- classy wrapper
mx_indexed_assignment''''''' :: MXClass a => a -> IMatrix -> IMatrix -> MX -> IO ()
mx_indexed_assignment''''''' x = casADi__MX__indexed_assignment''''''' (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__indexed_one_based_assignment_TIC" c_CasADi__MX__indexed_one_based_assignment_TIC
  :: Ptr MX' -> CInt -> Ptr MX' -> IO ()
casADi__MX__indexed_one_based_assignment'
  :: MX -> Int -> MX -> IO ()
casADi__MX__indexed_one_based_assignment' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__MX__indexed_one_based_assignment_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
mx_indexed_one_based_assignment' :: MXClass a => a -> Int -> MX -> IO ()
mx_indexed_one_based_assignment' x = casADi__MX__indexed_one_based_assignment' (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__indexed_zero_based_assignment_TIC_TIC" c_CasADi__MX__indexed_zero_based_assignment_TIC_TIC
  :: Ptr MX' -> CInt -> Ptr MX' -> IO ()
casADi__MX__indexed_zero_based_assignment''
  :: MX -> Int -> MX -> IO ()
casADi__MX__indexed_zero_based_assignment'' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__MX__indexed_zero_based_assignment_TIC_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
mx_indexed_zero_based_assignment'' :: MXClass a => a -> Int -> MX -> IO ()
mx_indexed_zero_based_assignment'' x = casADi__MX__indexed_zero_based_assignment'' (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__MX__indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC
  :: Ptr MX' -> Ptr IndexList' -> Ptr MX' -> IO ()
casADi__MX__indexed_assignment''''''''
  :: MX -> IndexList -> MX -> IO ()
casADi__MX__indexed_assignment'''''''' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__MX__indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
mx_indexed_assignment'''''''' :: MXClass a => a -> IndexList -> MX -> IO ()
mx_indexed_assignment'''''''' x = casADi__MX__indexed_assignment'''''''' (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__MX__indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC
  :: Ptr MX' -> Ptr Slice' -> Ptr MX' -> IO ()
casADi__MX__indexed_assignment'''''''''
  :: MX -> Slice -> MX -> IO ()
casADi__MX__indexed_assignment''''''''' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__MX__indexed_assignment_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
mx_indexed_assignment''''''''' :: MXClass a => a -> Slice -> MX -> IO ()
mx_indexed_assignment''''''''' x = casADi__MX__indexed_assignment''''''''' (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__sparsityRef" c_CasADi__MX__sparsityRef
  :: Ptr MX' -> IO (Ptr Sparsity')
casADi__MX__sparsityRef
  :: MX -> IO Sparsity
casADi__MX__sparsityRef x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__MX__sparsityRef x0' >>= wrapReturn

-- classy wrapper
{-|
>Access the sparsity, make a copy if there are multiple references to it.
-}
mx_sparsityRef :: MXClass a => a -> IO Sparsity
mx_sparsityRef x = casADi__MX__sparsityRef (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__erase" c_CasADi__MX__erase
  :: Ptr MX' -> Ptr (CppVec CInt) -> Ptr (CppVec CInt) -> IO ()
casADi__MX__erase
  :: MX -> Vector Int -> Vector Int -> IO ()
casADi__MX__erase x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__MX__erase x0' x1' x2' >>= wrapReturn

-- classy wrapper
{-|
>Erase a submatrix.
-}
mx_erase :: MXClass a => a -> Vector Int -> Vector Int -> IO ()
mx_erase x = casADi__MX__erase (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__enlarge" c_CasADi__MX__enlarge
  :: Ptr MX' -> CInt -> CInt -> Ptr (CppVec CInt) -> Ptr (CppVec CInt) -> IO ()
casADi__MX__enlarge
  :: MX -> Int -> Int -> Vector Int -> Vector Int -> IO ()
casADi__MX__enlarge x0 x1 x2 x3 x4 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  withMarshal x4 $ \x4' ->
  c_CasADi__MX__enlarge x0' x1' x2' x3' x4' >>= wrapReturn

-- classy wrapper
{-|
>Enlarge matrix Make the matrix larger by inserting empty rows and columns,
>keeping the existing non-zeros.
-}
mx_enlarge :: MXClass a => a -> Int -> Int -> Vector Int -> Vector Int -> IO ()
mx_enlarge x = casADi__MX__enlarge (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__operator_minus" c_CasADi__MX__operator_minus
  :: Ptr MX' -> IO (Ptr MX')
casADi__MX__operator_minus
  :: MX -> IO MX
casADi__MX__operator_minus x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__MX__operator_minus x0' >>= wrapReturn

-- classy wrapper
mx_operator_minus :: MXClass a => a -> IO MX
mx_operator_minus x = casADi__MX__operator_minus (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__getDep" c_CasADi__MX__getDep
  :: Ptr MX' -> CInt -> IO (Ptr MX')
casADi__MX__getDep
  :: MX -> Int -> IO MX
casADi__MX__getDep x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__MX__getDep x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>Get the nth dependency as MX.
-}
mx_getDep :: MXClass a => a -> Int -> IO MX
mx_getDep x = casADi__MX__getDep (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__getDep_TIC" c_CasADi__MX__getDep_TIC
  :: Ptr MX' -> IO (Ptr MX')
casADi__MX__getDep'
  :: MX -> IO MX
casADi__MX__getDep' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__MX__getDep_TIC x0' >>= wrapReturn

-- classy wrapper
mx_getDep' :: MXClass a => a -> IO MX
mx_getDep' x = casADi__MX__getDep' (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__getNumOutputs" c_CasADi__MX__getNumOutputs
  :: Ptr MX' -> IO CInt
casADi__MX__getNumOutputs
  :: MX -> IO Int
casADi__MX__getNumOutputs x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__MX__getNumOutputs x0' >>= wrapReturn

-- classy wrapper
{-|
>Number of outputs.
-}
mx_getNumOutputs :: MXClass a => a -> IO Int
mx_getNumOutputs x = casADi__MX__getNumOutputs (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__getOutput" c_CasADi__MX__getOutput
  :: Ptr MX' -> CInt -> IO (Ptr MX')
casADi__MX__getOutput
  :: MX -> Int -> IO MX
casADi__MX__getOutput x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__MX__getOutput x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>Get an output.
-}
mx_getOutput :: MXClass a => a -> Int -> IO MX
mx_getOutput x = casADi__MX__getOutput (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__getOutput_TIC" c_CasADi__MX__getOutput_TIC
  :: Ptr MX' -> IO (Ptr MX')
casADi__MX__getOutput'
  :: MX -> IO MX
casADi__MX__getOutput' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__MX__getOutput_TIC x0' >>= wrapReturn

-- classy wrapper
mx_getOutput' :: MXClass a => a -> IO MX
mx_getOutput' x = casADi__MX__getOutput' (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__getNdeps" c_CasADi__MX__getNdeps
  :: Ptr MX' -> IO CInt
casADi__MX__getNdeps
  :: MX -> IO Int
casADi__MX__getNdeps x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__MX__getNdeps x0' >>= wrapReturn

-- classy wrapper
{-|
>Get the number of dependencies of a binary SXElement.
-}
mx_getNdeps :: MXClass a => a -> IO Int
mx_getNdeps x = casADi__MX__getNdeps (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__getName" c_CasADi__MX__getName
  :: Ptr MX' -> IO (Ptr StdString')
casADi__MX__getName
  :: MX -> IO String
casADi__MX__getName x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__MX__getName x0' >>= wrapReturn

-- classy wrapper
{-|
>Get the name.
-}
mx_getName :: MXClass a => a -> IO String
mx_getName x = casADi__MX__getName (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__getValue" c_CasADi__MX__getValue
  :: Ptr MX' -> IO CDouble
casADi__MX__getValue
  :: MX -> IO Double
casADi__MX__getValue x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__MX__getValue x0' >>= wrapReturn

-- classy wrapper
{-|
>Get the value (only for scalar constant nodes)
-}
mx_getValue :: MXClass a => a -> IO Double
mx_getValue x = casADi__MX__getValue (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__getMatrixValue" c_CasADi__MX__getMatrixValue
  :: Ptr MX' -> IO (Ptr DMatrix')
casADi__MX__getMatrixValue
  :: MX -> IO DMatrix
casADi__MX__getMatrixValue x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__MX__getMatrixValue x0' >>= wrapReturn

-- classy wrapper
{-|
>Get the value (only for constant nodes)
-}
mx_getMatrixValue :: MXClass a => a -> IO DMatrix
mx_getMatrixValue x = casADi__MX__getMatrixValue (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__isSymbolic" c_CasADi__MX__isSymbolic
  :: Ptr MX' -> IO CInt
casADi__MX__isSymbolic
  :: MX -> IO Bool
casADi__MX__isSymbolic x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__MX__isSymbolic x0' >>= wrapReturn

-- classy wrapper
{-|
>Check if symbolic.
-}
mx_isSymbolic :: MXClass a => a -> IO Bool
mx_isSymbolic x = casADi__MX__isSymbolic (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__isConstant" c_CasADi__MX__isConstant
  :: Ptr MX' -> IO CInt
casADi__MX__isConstant
  :: MX -> IO Bool
casADi__MX__isConstant x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__MX__isConstant x0' >>= wrapReturn

-- classy wrapper
{-|
>Check if constant.
-}
mx_isConstant :: MXClass a => a -> IO Bool
mx_isConstant x = casADi__MX__isConstant (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__isEvaluation" c_CasADi__MX__isEvaluation
  :: Ptr MX' -> IO CInt
casADi__MX__isEvaluation
  :: MX -> IO Bool
casADi__MX__isEvaluation x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__MX__isEvaluation x0' >>= wrapReturn

-- classy wrapper
{-|
>Check if evaluation.
-}
mx_isEvaluation :: MXClass a => a -> IO Bool
mx_isEvaluation x = casADi__MX__isEvaluation (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__isEvaluationOutput" c_CasADi__MX__isEvaluationOutput
  :: Ptr MX' -> IO CInt
casADi__MX__isEvaluationOutput
  :: MX -> IO Bool
casADi__MX__isEvaluationOutput x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__MX__isEvaluationOutput x0' >>= wrapReturn

-- classy wrapper
{-|
>Check if evaluation output.
-}
mx_isEvaluationOutput :: MXClass a => a -> IO Bool
mx_isEvaluationOutput x = casADi__MX__isEvaluationOutput (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__getEvaluationOutput" c_CasADi__MX__getEvaluationOutput
  :: Ptr MX' -> IO CInt
casADi__MX__getEvaluationOutput
  :: MX -> IO Int
casADi__MX__getEvaluationOutput x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__MX__getEvaluationOutput x0' >>= wrapReturn

-- classy wrapper
{-|
>Get the index of evaluation output - only valid when isEvaluationoutput() is
>true.
-}
mx_getEvaluationOutput :: MXClass a => a -> IO Int
mx_getEvaluationOutput x = casADi__MX__getEvaluationOutput (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__isOperation" c_CasADi__MX__isOperation
  :: Ptr MX' -> CInt -> IO CInt
casADi__MX__isOperation
  :: MX -> Int -> IO Bool
casADi__MX__isOperation x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__MX__isOperation x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>Is it a certain operation.
-}
mx_isOperation :: MXClass a => a -> Int -> IO Bool
mx_isOperation x = casADi__MX__isOperation (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__isMultiplication" c_CasADi__MX__isMultiplication
  :: Ptr MX' -> IO CInt
casADi__MX__isMultiplication
  :: MX -> IO Bool
casADi__MX__isMultiplication x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__MX__isMultiplication x0' >>= wrapReturn

-- classy wrapper
{-|
>Check if multiplication.
-}
mx_isMultiplication :: MXClass a => a -> IO Bool
mx_isMultiplication x = casADi__MX__isMultiplication (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__isCommutative" c_CasADi__MX__isCommutative
  :: Ptr MX' -> IO CInt
casADi__MX__isCommutative
  :: MX -> IO Bool
casADi__MX__isCommutative x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__MX__isCommutative x0' >>= wrapReturn

-- classy wrapper
{-|
>Check if commutative operation.
-}
mx_isCommutative :: MXClass a => a -> IO Bool
mx_isCommutative x = casADi__MX__isCommutative (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__isNorm" c_CasADi__MX__isNorm
  :: Ptr MX' -> IO CInt
casADi__MX__isNorm
  :: MX -> IO Bool
casADi__MX__isNorm x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__MX__isNorm x0' >>= wrapReturn

-- classy wrapper
{-|
>Check if norm.
-}
mx_isNorm :: MXClass a => a -> IO Bool
mx_isNorm x = casADi__MX__isNorm (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__isSymbolicSparse" c_CasADi__MX__isSymbolicSparse
  :: Ptr MX' -> IO CInt
casADi__MX__isSymbolicSparse
  :: MX -> IO Bool
casADi__MX__isSymbolicSparse x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__MX__isSymbolicSparse x0' >>= wrapReturn

-- classy wrapper
{-|
>check if all nonzeros are symbolic (this function is currently identical to
>isSymbolic)
-}
mx_isSymbolicSparse :: MXClass a => a -> IO Bool
mx_isSymbolicSparse x = casADi__MX__isSymbolicSparse (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__isIdentity" c_CasADi__MX__isIdentity
  :: Ptr MX' -> IO CInt
casADi__MX__isIdentity
  :: MX -> IO Bool
casADi__MX__isIdentity x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__MX__isIdentity x0' >>= wrapReturn

-- classy wrapper
{-|
>check if identity
-}
mx_isIdentity :: MXClass a => a -> IO Bool
mx_isIdentity x = casADi__MX__isIdentity (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__isZero" c_CasADi__MX__isZero
  :: Ptr MX' -> IO CInt
casADi__MX__isZero
  :: MX -> IO Bool
casADi__MX__isZero x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__MX__isZero x0' >>= wrapReturn

-- classy wrapper
{-|
>check if zero (note that false negative answers are possible)
-}
mx_isZero :: MXClass a => a -> IO Bool
mx_isZero x = casADi__MX__isZero (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__isOne" c_CasADi__MX__isOne
  :: Ptr MX' -> IO CInt
casADi__MX__isOne
  :: MX -> IO Bool
casADi__MX__isOne x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__MX__isOne x0' >>= wrapReturn

-- classy wrapper
{-|
>check if zero (note that false negative answers are possible)
-}
mx_isOne :: MXClass a => a -> IO Bool
mx_isOne x = casADi__MX__isOne (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__isMinusOne" c_CasADi__MX__isMinusOne
  :: Ptr MX' -> IO CInt
casADi__MX__isMinusOne
  :: MX -> IO Bool
casADi__MX__isMinusOne x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__MX__isMinusOne x0' >>= wrapReturn

-- classy wrapper
{-|
>check if zero (note that false negative answers are possible)
-}
mx_isMinusOne :: MXClass a => a -> IO Bool
mx_isMinusOne x = casADi__MX__isMinusOne (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__isTranspose" c_CasADi__MX__isTranspose
  :: Ptr MX' -> IO CInt
casADi__MX__isTranspose
  :: MX -> IO Bool
casADi__MX__isTranspose x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__MX__isTranspose x0' >>= wrapReturn

-- classy wrapper
{-|
>Is the expression a transpose?
-}
mx_isTranspose :: MXClass a => a -> IO Bool
mx_isTranspose x = casADi__MX__isTranspose (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__isRegular" c_CasADi__MX__isRegular
  :: Ptr MX' -> IO CInt
casADi__MX__isRegular
  :: MX -> IO Bool
casADi__MX__isRegular x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__MX__isRegular x0' >>= wrapReturn

-- classy wrapper
{-|
>Checks if expression does not contain NaN or Inf.
-}
mx_isRegular :: MXClass a => a -> IO Bool
mx_isRegular x = casADi__MX__isRegular (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__getFunction" c_CasADi__MX__getFunction
  :: Ptr MX' -> IO (Ptr Function')
casADi__MX__getFunction
  :: MX -> IO Function
casADi__MX__getFunction x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__MX__getFunction x0' >>= wrapReturn

-- classy wrapper
{-|
>Get function.
-}
mx_getFunction :: MXClass a => a -> IO Function
mx_getFunction x = casADi__MX__getFunction (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__isBinary" c_CasADi__MX__isBinary
  :: Ptr MX' -> IO CInt
casADi__MX__isBinary
  :: MX -> IO Bool
casADi__MX__isBinary x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__MX__isBinary x0' >>= wrapReturn

-- classy wrapper
{-|
>Is binary operation.
-}
mx_isBinary :: MXClass a => a -> IO Bool
mx_isBinary x = casADi__MX__isBinary (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__isUnary" c_CasADi__MX__isUnary
  :: Ptr MX' -> IO CInt
casADi__MX__isUnary
  :: MX -> IO Bool
casADi__MX__isUnary x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__MX__isUnary x0' >>= wrapReturn

-- classy wrapper
{-|
>Is unary operation.
-}
mx_isUnary :: MXClass a => a -> IO Bool
mx_isUnary x = casADi__MX__isUnary (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__getOp" c_CasADi__MX__getOp
  :: Ptr MX' -> IO CInt
casADi__MX__getOp
  :: MX -> IO Int
casADi__MX__getOp x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__MX__getOp x0' >>= wrapReturn

-- classy wrapper
{-|
>Get operation type.
-}
mx_getOp :: MXClass a => a -> IO Int
mx_getOp x = casADi__MX__getOp (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__isEqual" c_CasADi__MX__isEqual
  :: Ptr MX' -> Ptr MX' -> CInt -> IO CInt
casADi__MX__isEqual
  :: MX -> MX -> Int -> IO Bool
casADi__MX__isEqual x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__MX__isEqual x0' x1' x2' >>= wrapReturn

-- classy wrapper
{-|
>>  bool CasADi::MX::isEqual(const MX &y, int depth=0) const 
>------------------------------------------------------------------------
>
>Check if two nodes are equivalent up to a given depth. Depth=0 checks if the
>expressions are identical, i.e. points to the same node.
>
>a = x*x b = x*x
>
>a.isEqual(b,0) will return false, but a.isEqual(b,1) will return true
>
>>  bool CasADi::MX::isEqual(const MXNode *y, int depth=0) const 
>------------------------------------------------------------------------
>[INTERNAL] 
-}
mx_isEqual :: MXClass a => a -> MX -> Int -> IO Bool
mx_isEqual x = casADi__MX__isEqual (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__isEqual_TIC" c_CasADi__MX__isEqual_TIC
  :: Ptr MX' -> Ptr MX' -> IO CInt
casADi__MX__isEqual'
  :: MX -> MX -> IO Bool
casADi__MX__isEqual' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__MX__isEqual_TIC x0' x1' >>= wrapReturn

-- classy wrapper
mx_isEqual' :: MXClass a => a -> MX -> IO Bool
mx_isEqual' x = casADi__MX__isEqual' (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX____hash__" c_CasADi__MX____hash__
  :: Ptr MX' -> IO CLong
casADi__MX____hash__
  :: MX -> IO Int
casADi__MX____hash__ x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__MX____hash__ x0' >>= wrapReturn

-- classy wrapper
{-|
>Returns a number that is unique for a given MXNode. If the MX does not point
>to any node, 0 is returned.
-}
mx___hash__ :: MXClass a => a -> IO Int
mx___hash__ x = casADi__MX____hash__ (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__getTemp" c_CasADi__MX__getTemp
  :: Ptr MX' -> IO CInt
casADi__MX__getTemp
  :: MX -> IO Int
casADi__MX__getTemp x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__MX__getTemp x0' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Get the temporary
>variable
-}
mx_getTemp :: MXClass a => a -> IO Int
mx_getTemp x = casADi__MX__getTemp (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__setTemp" c_CasADi__MX__setTemp
  :: Ptr MX' -> CInt -> IO ()
casADi__MX__setTemp
  :: MX -> Int -> IO ()
casADi__MX__setTemp x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__MX__setTemp x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]  Set the temporary
>variable.
-}
mx_setTemp :: MXClass a => a -> Int -> IO ()
mx_setTemp x = casADi__MX__setTemp (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__binary" c_CasADi__MX__binary
  :: CInt -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
casADi__MX__binary
  :: Int -> MX -> MX -> IO MX
casADi__MX__binary x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__MX__binary x0' x1' x2' >>= wrapReturn

-- classy wrapper
{-|
>Create nodes by their ID.
-}
mx_binary :: Int -> MX -> MX -> IO MX
mx_binary = casADi__MX__binary


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__unary" c_CasADi__MX__unary
  :: CInt -> Ptr MX' -> IO (Ptr MX')
casADi__MX__unary
  :: Int -> MX -> IO MX
casADi__MX__unary x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__MX__unary x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>Create nodes by their ID.
-}
mx_unary :: Int -> MX -> IO MX
mx_unary = casADi__MX__unary


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__inf" c_CasADi__MX__inf
  :: Ptr Sparsity' -> IO (Ptr MX')
casADi__MX__inf
  :: Sparsity -> IO MX
casADi__MX__inf x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__MX__inf x0' >>= wrapReturn

-- classy wrapper
{-|
>create a matrix with all inf
-}
mx_inf :: Sparsity -> IO MX
mx_inf = casADi__MX__inf


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__inf_TIC" c_CasADi__MX__inf_TIC
  :: CInt -> CInt -> IO (Ptr MX')
casADi__MX__inf'
  :: Int -> Int -> IO MX
casADi__MX__inf' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__MX__inf_TIC x0' x1' >>= wrapReturn

-- classy wrapper
mx_inf' :: Int -> Int -> IO MX
mx_inf' = casADi__MX__inf'


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__inf_TIC_TIC" c_CasADi__MX__inf_TIC_TIC
  :: CInt -> IO (Ptr MX')
casADi__MX__inf''
  :: Int -> IO MX
casADi__MX__inf'' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__MX__inf_TIC_TIC x0' >>= wrapReturn

-- classy wrapper
mx_inf'' :: Int -> IO MX
mx_inf'' = casADi__MX__inf''


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__inf_TIC_TIC_TIC" c_CasADi__MX__inf_TIC_TIC_TIC
  :: IO (Ptr MX')
casADi__MX__inf'''
  :: IO MX
casADi__MX__inf'''  =
  c_CasADi__MX__inf_TIC_TIC_TIC  >>= wrapReturn

-- classy wrapper
mx_inf''' :: IO MX
mx_inf''' = casADi__MX__inf'''


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__nan" c_CasADi__MX__nan
  :: Ptr Sparsity' -> IO (Ptr MX')
casADi__MX__nan
  :: Sparsity -> IO MX
casADi__MX__nan x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__MX__nan x0' >>= wrapReturn

-- classy wrapper
{-|
>create a matrix with all nan
-}
mx_nan :: Sparsity -> IO MX
mx_nan = casADi__MX__nan


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__nan_TIC" c_CasADi__MX__nan_TIC
  :: CInt -> CInt -> IO (Ptr MX')
casADi__MX__nan'
  :: Int -> Int -> IO MX
casADi__MX__nan' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__MX__nan_TIC x0' x1' >>= wrapReturn

-- classy wrapper
mx_nan' :: Int -> Int -> IO MX
mx_nan' = casADi__MX__nan'


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__nan_TIC_TIC" c_CasADi__MX__nan_TIC_TIC
  :: CInt -> IO (Ptr MX')
casADi__MX__nan''
  :: Int -> IO MX
casADi__MX__nan'' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__MX__nan_TIC_TIC x0' >>= wrapReturn

-- classy wrapper
mx_nan'' :: Int -> IO MX
mx_nan'' = casADi__MX__nan''


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__nan_TIC_TIC_TIC" c_CasADi__MX__nan_TIC_TIC_TIC
  :: IO (Ptr MX')
casADi__MX__nan'''
  :: IO MX
casADi__MX__nan'''  =
  c_CasADi__MX__nan_TIC_TIC_TIC  >>= wrapReturn

-- classy wrapper
mx_nan''' :: IO MX
mx_nan''' = casADi__MX__nan'''


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__repmat" c_CasADi__MX__repmat
  :: Ptr MX' -> Ptr Sparsity' -> IO (Ptr MX')
casADi__MX__repmat
  :: MX -> Sparsity -> IO MX
casADi__MX__repmat x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__MX__repmat x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>create a matrix by repeating an existing matrix
-}
mx_repmat :: MX -> Sparsity -> IO MX
mx_repmat = casADi__MX__repmat


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__repmat_TIC" c_CasADi__MX__repmat_TIC
  :: Ptr MX' -> CInt -> CInt -> IO (Ptr MX')
casADi__MX__repmat'
  :: MX -> Int -> Int -> IO MX
casADi__MX__repmat' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__MX__repmat_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
mx_repmat' :: MX -> Int -> Int -> IO MX
mx_repmat' = casADi__MX__repmat'


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__repmat_TIC_TIC" c_CasADi__MX__repmat_TIC_TIC
  :: Ptr MX' -> CInt -> IO (Ptr MX')
casADi__MX__repmat''
  :: MX -> Int -> IO MX
casADi__MX__repmat'' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__MX__repmat_TIC_TIC x0' x1' >>= wrapReturn

-- classy wrapper
mx_repmat'' :: MX -> Int -> IO MX
mx_repmat'' = casADi__MX__repmat''


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__eye" c_CasADi__MX__eye
  :: CInt -> IO (Ptr MX')
casADi__MX__eye
  :: Int -> IO MX
casADi__MX__eye x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__MX__eye x0' >>= wrapReturn

-- classy wrapper
mx_eye :: Int -> IO MX
mx_eye = casADi__MX__eye


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__setSub" c_CasADi__MX__setSub
  :: Ptr MX' -> Ptr MX' -> CInt -> CInt -> IO ()
casADi__MX__setSub
  :: MX -> MX -> Int -> Int -> IO ()
casADi__MX__setSub x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  c_CasADi__MX__setSub x0' x1' x2' x3' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL] 
-}
mx_setSub :: MXClass a => a -> MX -> Int -> Int -> IO ()
mx_setSub x = casADi__MX__setSub (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__setSub_TIC" c_CasADi__MX__setSub_TIC
  :: Ptr MX' -> Ptr MX' -> Ptr (CppVec CInt) -> CInt -> IO ()
casADi__MX__setSub'
  :: MX -> MX -> Vector Int -> Int -> IO ()
casADi__MX__setSub' x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  c_CasADi__MX__setSub_TIC x0' x1' x2' x3' >>= wrapReturn

-- classy wrapper
mx_setSub' :: MXClass a => a -> MX -> Vector Int -> Int -> IO ()
mx_setSub' x = casADi__MX__setSub' (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__setSub_TIC_TIC" c_CasADi__MX__setSub_TIC_TIC
  :: Ptr MX' -> Ptr MX' -> CInt -> Ptr (CppVec CInt) -> IO ()
casADi__MX__setSub''
  :: MX -> MX -> Int -> Vector Int -> IO ()
casADi__MX__setSub'' x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  c_CasADi__MX__setSub_TIC_TIC x0' x1' x2' x3' >>= wrapReturn

-- classy wrapper
mx_setSub'' :: MXClass a => a -> MX -> Int -> Vector Int -> IO ()
mx_setSub'' x = casADi__MX__setSub'' (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__setSub_TIC_TIC_TIC" c_CasADi__MX__setSub_TIC_TIC_TIC
  :: Ptr MX' -> Ptr MX' -> Ptr (CppVec CInt) -> Ptr (CppVec CInt) -> IO ()
casADi__MX__setSub'''
  :: MX -> MX -> Vector Int -> Vector Int -> IO ()
casADi__MX__setSub''' x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  c_CasADi__MX__setSub_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn

-- classy wrapper
mx_setSub''' :: MXClass a => a -> MX -> Vector Int -> Vector Int -> IO ()
mx_setSub''' x = casADi__MX__setSub''' (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__setSub_TIC_TIC_TIC_TIC" c_CasADi__MX__setSub_TIC_TIC_TIC_TIC
  :: Ptr MX' -> Ptr MX' -> Ptr IMatrix' -> IO ()
casADi__MX__setSub''''
  :: MX -> MX -> IMatrix -> IO ()
casADi__MX__setSub'''' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__MX__setSub_TIC_TIC_TIC_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
mx_setSub'''' :: MXClass a => a -> MX -> IMatrix -> IO ()
mx_setSub'''' x = casADi__MX__setSub'''' (castMX x)


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

-- classy wrapper
mx_setSub''''' :: MXClass a => a -> MX -> IMatrix -> Vector Int -> IO ()
mx_setSub''''' x = casADi__MX__setSub''''' (castMX x)


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

-- classy wrapper
mx_setSub'''''' :: MXClass a => a -> MX -> Vector Int -> IMatrix -> IO ()
mx_setSub'''''' x = casADi__MX__setSub'''''' (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__MX__setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC
  :: Ptr MX' -> Ptr MX' -> Ptr Slice' -> Ptr Slice' -> IO ()
casADi__MX__setSub'''''''
  :: MX -> MX -> Slice -> Slice -> IO ()
casADi__MX__setSub''''''' x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  c_CasADi__MX__setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn

-- classy wrapper
mx_setSub''''''' :: MXClass a => a -> MX -> Slice -> Slice -> IO ()
mx_setSub''''''' x = casADi__MX__setSub''''''' (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__MX__setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC
  :: Ptr MX' -> Ptr MX' -> Ptr IMatrix' -> Ptr IMatrix' -> IO ()
casADi__MX__setSub''''''''
  :: MX -> MX -> IMatrix -> IMatrix -> IO ()
casADi__MX__setSub'''''''' x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  c_CasADi__MX__setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn

-- classy wrapper
mx_setSub'''''''' :: MXClass a => a -> MX -> IMatrix -> IMatrix -> IO ()
mx_setSub'''''''' x = casADi__MX__setSub'''''''' (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__MX__setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC
  :: Ptr MX' -> Ptr MX' -> Ptr Sparsity' -> CInt -> IO ()
casADi__MX__setSub'''''''''
  :: MX -> MX -> Sparsity -> Int -> IO ()
casADi__MX__setSub''''''''' x0 x1 x2 x3 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  withMarshal x3 $ \x3' ->
  c_CasADi__MX__setSub_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn

-- classy wrapper
mx_setSub''''''''' :: MXClass a => a -> MX -> Sparsity -> Int -> IO ()
mx_setSub''''''''' x = casADi__MX__setSub''''''''' (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__getNZ" c_CasADi__MX__getNZ
  :: Ptr MX' -> CInt -> IO (Ptr MX')
casADi__MX__getNZ
  :: MX -> Int -> IO MX
casADi__MX__getNZ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__MX__getNZ x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL] 
-}
mx_getNZ :: MXClass a => a -> Int -> IO MX
mx_getNZ x = casADi__MX__getNZ (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__getNZ_TIC" c_CasADi__MX__getNZ_TIC
  :: Ptr MX' -> Ptr (CppVec CInt) -> IO (Ptr MX')
casADi__MX__getNZ'
  :: MX -> Vector Int -> IO MX
casADi__MX__getNZ' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__MX__getNZ_TIC x0' x1' >>= wrapReturn

-- classy wrapper
mx_getNZ' :: MXClass a => a -> Vector Int -> IO MX
mx_getNZ' x = casADi__MX__getNZ' (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__getNZ_TIC_TIC" c_CasADi__MX__getNZ_TIC_TIC
  :: Ptr MX' -> Ptr Slice' -> IO (Ptr MX')
casADi__MX__getNZ''
  :: MX -> Slice -> IO MX
casADi__MX__getNZ'' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__MX__getNZ_TIC_TIC x0' x1' >>= wrapReturn

-- classy wrapper
mx_getNZ'' :: MXClass a => a -> Slice -> IO MX
mx_getNZ'' x = casADi__MX__getNZ'' (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__getNZ_TIC_TIC_TIC" c_CasADi__MX__getNZ_TIC_TIC_TIC
  :: Ptr MX' -> Ptr IMatrix' -> IO (Ptr MX')
casADi__MX__getNZ'''
  :: MX -> IMatrix -> IO MX
casADi__MX__getNZ''' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__MX__getNZ_TIC_TIC_TIC x0' x1' >>= wrapReturn

-- classy wrapper
mx_getNZ''' :: MXClass a => a -> IMatrix -> IO MX
mx_getNZ''' x = casADi__MX__getNZ''' (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__setNZ" c_CasADi__MX__setNZ
  :: Ptr MX' -> CInt -> Ptr MX' -> IO ()
casADi__MX__setNZ
  :: MX -> Int -> MX -> IO ()
casADi__MX__setNZ x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__MX__setNZ x0' x1' x2' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL] 
-}
mx_setNZ :: MXClass a => a -> Int -> MX -> IO ()
mx_setNZ x = casADi__MX__setNZ (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__setNZ_TIC" c_CasADi__MX__setNZ_TIC
  :: Ptr MX' -> Ptr (CppVec CInt) -> Ptr MX' -> IO ()
casADi__MX__setNZ'
  :: MX -> Vector Int -> MX -> IO ()
casADi__MX__setNZ' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__MX__setNZ_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
mx_setNZ' :: MXClass a => a -> Vector Int -> MX -> IO ()
mx_setNZ' x = casADi__MX__setNZ' (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__setNZ_TIC_TIC" c_CasADi__MX__setNZ_TIC_TIC
  :: Ptr MX' -> Ptr Slice' -> Ptr MX' -> IO ()
casADi__MX__setNZ''
  :: MX -> Slice -> MX -> IO ()
casADi__MX__setNZ'' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__MX__setNZ_TIC_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
mx_setNZ'' :: MXClass a => a -> Slice -> MX -> IO ()
mx_setNZ'' x = casADi__MX__setNZ'' (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__setNZ_TIC_TIC_TIC" c_CasADi__MX__setNZ_TIC_TIC_TIC
  :: Ptr MX' -> Ptr IMatrix' -> Ptr MX' -> IO ()
casADi__MX__setNZ'''
  :: MX -> IMatrix -> MX -> IO ()
casADi__MX__setNZ''' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__MX__setNZ_TIC_TIC_TIC x0' x1' x2' >>= wrapReturn

-- classy wrapper
mx_setNZ''' :: MXClass a => a -> IMatrix -> MX -> IO ()
mx_setNZ''' x = casADi__MX__setNZ''' (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__append" c_CasADi__MX__append
  :: Ptr MX' -> Ptr MX' -> IO ()
casADi__MX__append
  :: MX -> MX -> IO ()
casADi__MX__append x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__MX__append x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>Append a matrix vertically (NOTE: only efficient if vector)
-}
mx_append :: MXClass a => a -> MX -> IO ()
mx_append x = casADi__MX__append (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__appendColumns" c_CasADi__MX__appendColumns
  :: Ptr MX' -> Ptr MX' -> IO ()
casADi__MX__appendColumns
  :: MX -> MX -> IO ()
casADi__MX__appendColumns x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__MX__appendColumns x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>Append a matrix horizontally.
-}
mx_appendColumns :: MXClass a => a -> MX -> IO ()
mx_appendColumns x = casADi__MX__appendColumns (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX____add__" c_CasADi__MX____add__
  :: Ptr MX' -> Ptr MX' -> IO (Ptr MX')
casADi__MX____add__
  :: MX -> MX -> IO MX
casADi__MX____add__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__MX____add__ x0' x1' >>= wrapReturn

-- classy wrapper
mx___add__ :: MXClass a => a -> MX -> IO MX
mx___add__ x = casADi__MX____add__ (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX____sub__" c_CasADi__MX____sub__
  :: Ptr MX' -> Ptr MX' -> IO (Ptr MX')
casADi__MX____sub__
  :: MX -> MX -> IO MX
casADi__MX____sub__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__MX____sub__ x0' x1' >>= wrapReturn

-- classy wrapper
mx___sub__ :: MXClass a => a -> MX -> IO MX
mx___sub__ x = casADi__MX____sub__ (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX____mul__" c_CasADi__MX____mul__
  :: Ptr MX' -> Ptr MX' -> IO (Ptr MX')
casADi__MX____mul__
  :: MX -> MX -> IO MX
casADi__MX____mul__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__MX____mul__ x0' x1' >>= wrapReturn

-- classy wrapper
mx___mul__ :: MXClass a => a -> MX -> IO MX
mx___mul__ x = casADi__MX____mul__ (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX____div__" c_CasADi__MX____div__
  :: Ptr MX' -> Ptr MX' -> IO (Ptr MX')
casADi__MX____div__
  :: MX -> MX -> IO MX
casADi__MX____div__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__MX____div__ x0' x1' >>= wrapReturn

-- classy wrapper
mx___div__ :: MXClass a => a -> MX -> IO MX
mx___div__ x = casADi__MX____div__ (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX____lt__" c_CasADi__MX____lt__
  :: Ptr MX' -> Ptr MX' -> IO (Ptr MX')
casADi__MX____lt__
  :: MX -> MX -> IO MX
casADi__MX____lt__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__MX____lt__ x0' x1' >>= wrapReturn

-- classy wrapper
mx___lt__ :: MXClass a => a -> MX -> IO MX
mx___lt__ x = casADi__MX____lt__ (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX____le__" c_CasADi__MX____le__
  :: Ptr MX' -> Ptr MX' -> IO (Ptr MX')
casADi__MX____le__
  :: MX -> MX -> IO MX
casADi__MX____le__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__MX____le__ x0' x1' >>= wrapReturn

-- classy wrapper
mx___le__ :: MXClass a => a -> MX -> IO MX
mx___le__ x = casADi__MX____le__ (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX____eq__" c_CasADi__MX____eq__
  :: Ptr MX' -> Ptr MX' -> IO (Ptr MX')
casADi__MX____eq__
  :: MX -> MX -> IO MX
casADi__MX____eq__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__MX____eq__ x0' x1' >>= wrapReturn

-- classy wrapper
mx___eq__ :: MXClass a => a -> MX -> IO MX
mx___eq__ x = casADi__MX____eq__ (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX____ne__" c_CasADi__MX____ne__
  :: Ptr MX' -> Ptr MX' -> IO (Ptr MX')
casADi__MX____ne__
  :: MX -> MX -> IO MX
casADi__MX____ne__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__MX____ne__ x0' x1' >>= wrapReturn

-- classy wrapper
mx___ne__ :: MXClass a => a -> MX -> IO MX
mx___ne__ x = casADi__MX____ne__ (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX____truediv__" c_CasADi__MX____truediv__
  :: Ptr MX' -> Ptr MX' -> IO (Ptr MX')
casADi__MX____truediv__
  :: MX -> MX -> IO MX
casADi__MX____truediv__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__MX____truediv__ x0' x1' >>= wrapReturn

-- classy wrapper
mx___truediv__ :: MXClass a => a -> MX -> IO MX
mx___truediv__ x = casADi__MX____truediv__ (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX____pow__" c_CasADi__MX____pow__
  :: Ptr MX' -> Ptr MX' -> IO (Ptr MX')
casADi__MX____pow__
  :: MX -> MX -> IO MX
casADi__MX____pow__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__MX____pow__ x0' x1' >>= wrapReturn

-- classy wrapper
mx___pow__ :: MXClass a => a -> MX -> IO MX
mx___pow__ x = casADi__MX____pow__ (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX____constpow__" c_CasADi__MX____constpow__
  :: Ptr MX' -> Ptr MX' -> IO (Ptr MX')
casADi__MX____constpow__
  :: MX -> MX -> IO MX
casADi__MX____constpow__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__MX____constpow__ x0' x1' >>= wrapReturn

-- classy wrapper
mx___constpow__ :: MXClass a => a -> MX -> IO MX
mx___constpow__ x = casADi__MX____constpow__ (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX____mrdivide__" c_CasADi__MX____mrdivide__
  :: Ptr MX' -> Ptr MX' -> IO (Ptr MX')
casADi__MX____mrdivide__
  :: MX -> MX -> IO MX
casADi__MX____mrdivide__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__MX____mrdivide__ x0' x1' >>= wrapReturn

-- classy wrapper
mx___mrdivide__ :: MXClass a => a -> MX -> IO MX
mx___mrdivide__ x = casADi__MX____mrdivide__ (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX____mpower__" c_CasADi__MX____mpower__
  :: Ptr MX' -> Ptr MX' -> IO (Ptr MX')
casADi__MX____mpower__
  :: MX -> MX -> IO MX
casADi__MX____mpower__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__MX____mpower__ x0' x1' >>= wrapReturn

-- classy wrapper
mx___mpower__ :: MXClass a => a -> MX -> IO MX
mx___mpower__ x = casADi__MX____mpower__ (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__mul" c_CasADi__MX__mul
  :: Ptr MX' -> Ptr MX' -> Ptr Sparsity' -> IO (Ptr MX')
casADi__MX__mul
  :: MX -> MX -> Sparsity -> IO MX
casADi__MX__mul x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__MX__mul x0' x1' x2' >>= wrapReturn

-- classy wrapper
mx_mul :: MXClass a => a -> MX -> Sparsity -> IO MX
mx_mul x = casADi__MX__mul (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__mul_TIC" c_CasADi__MX__mul_TIC
  :: Ptr MX' -> Ptr MX' -> IO (Ptr MX')
casADi__MX__mul'
  :: MX -> MX -> IO MX
casADi__MX__mul' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__MX__mul_TIC x0' x1' >>= wrapReturn

-- classy wrapper
mx_mul' :: MXClass a => a -> MX -> IO MX
mx_mul' x = casADi__MX__mul' (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__mul_full" c_CasADi__MX__mul_full
  :: Ptr MX' -> Ptr MX' -> Ptr Sparsity' -> IO (Ptr MX')
casADi__MX__mul_full
  :: MX -> MX -> Sparsity -> IO MX
casADi__MX__mul_full x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__MX__mul_full x0' x1' x2' >>= wrapReturn

-- classy wrapper
mx_mul_full :: MXClass a => a -> MX -> Sparsity -> IO MX
mx_mul_full x = casADi__MX__mul_full (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__mul_full_TIC" c_CasADi__MX__mul_full_TIC
  :: Ptr MX' -> Ptr MX' -> IO (Ptr MX')
casADi__MX__mul_full'
  :: MX -> MX -> IO MX
casADi__MX__mul_full' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__MX__mul_full_TIC x0' x1' >>= wrapReturn

-- classy wrapper
mx_mul_full' :: MXClass a => a -> MX -> IO MX
mx_mul_full' x = casADi__MX__mul_full' (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__inner_prod" c_CasADi__MX__inner_prod
  :: Ptr MX' -> Ptr MX' -> IO (Ptr MX')
casADi__MX__inner_prod
  :: MX -> MX -> IO MX
casADi__MX__inner_prod x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__MX__inner_prod x0' x1' >>= wrapReturn

-- classy wrapper
mx_inner_prod :: MXClass a => a -> MX -> IO MX
mx_inner_prod x = casADi__MX__inner_prod (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__outer_prod" c_CasADi__MX__outer_prod
  :: Ptr MX' -> Ptr MX' -> IO (Ptr MX')
casADi__MX__outer_prod
  :: MX -> MX -> IO MX
casADi__MX__outer_prod x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__MX__outer_prod x0' x1' >>= wrapReturn

-- classy wrapper
mx_outer_prod :: MXClass a => a -> MX -> IO MX
mx_outer_prod x = casADi__MX__outer_prod (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__constpow" c_CasADi__MX__constpow
  :: Ptr MX' -> Ptr MX' -> IO (Ptr MX')
casADi__MX__constpow
  :: MX -> MX -> IO MX
casADi__MX__constpow x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__MX__constpow x0' x1' >>= wrapReturn

-- classy wrapper
mx_constpow :: MXClass a => a -> MX -> IO MX
mx_constpow x = casADi__MX__constpow (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__fmin" c_CasADi__MX__fmin
  :: Ptr MX' -> Ptr MX' -> IO (Ptr MX')
casADi__MX__fmin
  :: MX -> MX -> IO MX
casADi__MX__fmin x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__MX__fmin x0' x1' >>= wrapReturn

-- classy wrapper
mx_fmin :: MXClass a => a -> MX -> IO MX
mx_fmin x = casADi__MX__fmin (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__fmax" c_CasADi__MX__fmax
  :: Ptr MX' -> Ptr MX' -> IO (Ptr MX')
casADi__MX__fmax
  :: MX -> MX -> IO MX
casADi__MX__fmax x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__MX__fmax x0' x1' >>= wrapReturn

-- classy wrapper
mx_fmax :: MXClass a => a -> MX -> IO MX
mx_fmax x = casADi__MX__fmax (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__printme" c_CasADi__MX__printme
  :: Ptr MX' -> Ptr MX' -> IO (Ptr MX')
casADi__MX__printme
  :: MX -> MX -> IO MX
casADi__MX__printme x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__MX__printme x0' x1' >>= wrapReturn

-- classy wrapper
mx_printme :: MXClass a => a -> MX -> IO MX
mx_printme x = casADi__MX__printme (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__arctan2" c_CasADi__MX__arctan2
  :: Ptr MX' -> Ptr MX' -> IO (Ptr MX')
casADi__MX__arctan2
  :: MX -> MX -> IO MX
casADi__MX__arctan2 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__MX__arctan2 x0' x1' >>= wrapReturn

-- classy wrapper
mx_arctan2 :: MXClass a => a -> MX -> IO MX
mx_arctan2 x = casADi__MX__arctan2 (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__logic_and" c_CasADi__MX__logic_and
  :: Ptr MX' -> Ptr MX' -> IO (Ptr MX')
casADi__MX__logic_and
  :: MX -> MX -> IO MX
casADi__MX__logic_and x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__MX__logic_and x0' x1' >>= wrapReturn

-- classy wrapper
mx_logic_and :: MXClass a => a -> MX -> IO MX
mx_logic_and x = casADi__MX__logic_and (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__logic_or" c_CasADi__MX__logic_or
  :: Ptr MX' -> Ptr MX' -> IO (Ptr MX')
casADi__MX__logic_or
  :: MX -> MX -> IO MX
casADi__MX__logic_or x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__MX__logic_or x0' x1' >>= wrapReturn

-- classy wrapper
mx_logic_or :: MXClass a => a -> MX -> IO MX
mx_logic_or x = casADi__MX__logic_or (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__if_else_zero" c_CasADi__MX__if_else_zero
  :: Ptr MX' -> Ptr MX' -> IO (Ptr MX')
casADi__MX__if_else_zero
  :: MX -> MX -> IO MX
casADi__MX__if_else_zero x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__MX__if_else_zero x0' x1' >>= wrapReturn

-- classy wrapper
mx_if_else_zero :: MXClass a => a -> MX -> IO MX
mx_if_else_zero x = casADi__MX__if_else_zero (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX____copysign__" c_CasADi__MX____copysign__
  :: Ptr MX' -> Ptr MX' -> IO (Ptr MX')
casADi__MX____copysign__
  :: MX -> MX -> IO MX
casADi__MX____copysign__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__MX____copysign__ x0' x1' >>= wrapReturn

-- classy wrapper
mx___copysign__ :: MXClass a => a -> MX -> IO MX
mx___copysign__ x = casADi__MX____copysign__ (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__exp" c_CasADi__MX__exp
  :: Ptr MX' -> IO (Ptr MX')
casADi__MX__exp
  :: MX -> IO MX
casADi__MX__exp x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__MX__exp x0' >>= wrapReturn

-- classy wrapper
mx_exp :: MXClass a => a -> IO MX
mx_exp x = casADi__MX__exp (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__log" c_CasADi__MX__log
  :: Ptr MX' -> IO (Ptr MX')
casADi__MX__log
  :: MX -> IO MX
casADi__MX__log x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__MX__log x0' >>= wrapReturn

-- classy wrapper
mx_log :: MXClass a => a -> IO MX
mx_log x = casADi__MX__log (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__log10" c_CasADi__MX__log10
  :: Ptr MX' -> IO (Ptr MX')
casADi__MX__log10
  :: MX -> IO MX
casADi__MX__log10 x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__MX__log10 x0' >>= wrapReturn

-- classy wrapper
mx_log10 :: MXClass a => a -> IO MX
mx_log10 x = casADi__MX__log10 (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__sqrt" c_CasADi__MX__sqrt
  :: Ptr MX' -> IO (Ptr MX')
casADi__MX__sqrt
  :: MX -> IO MX
casADi__MX__sqrt x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__MX__sqrt x0' >>= wrapReturn

-- classy wrapper
mx_sqrt :: MXClass a => a -> IO MX
mx_sqrt x = casADi__MX__sqrt (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__sin" c_CasADi__MX__sin
  :: Ptr MX' -> IO (Ptr MX')
casADi__MX__sin
  :: MX -> IO MX
casADi__MX__sin x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__MX__sin x0' >>= wrapReturn

-- classy wrapper
mx_sin :: MXClass a => a -> IO MX
mx_sin x = casADi__MX__sin (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__cos" c_CasADi__MX__cos
  :: Ptr MX' -> IO (Ptr MX')
casADi__MX__cos
  :: MX -> IO MX
casADi__MX__cos x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__MX__cos x0' >>= wrapReturn

-- classy wrapper
mx_cos :: MXClass a => a -> IO MX
mx_cos x = casADi__MX__cos (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__tan" c_CasADi__MX__tan
  :: Ptr MX' -> IO (Ptr MX')
casADi__MX__tan
  :: MX -> IO MX
casADi__MX__tan x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__MX__tan x0' >>= wrapReturn

-- classy wrapper
mx_tan :: MXClass a => a -> IO MX
mx_tan x = casADi__MX__tan (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__arcsin" c_CasADi__MX__arcsin
  :: Ptr MX' -> IO (Ptr MX')
casADi__MX__arcsin
  :: MX -> IO MX
casADi__MX__arcsin x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__MX__arcsin x0' >>= wrapReturn

-- classy wrapper
mx_arcsin :: MXClass a => a -> IO MX
mx_arcsin x = casADi__MX__arcsin (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__arccos" c_CasADi__MX__arccos
  :: Ptr MX' -> IO (Ptr MX')
casADi__MX__arccos
  :: MX -> IO MX
casADi__MX__arccos x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__MX__arccos x0' >>= wrapReturn

-- classy wrapper
mx_arccos :: MXClass a => a -> IO MX
mx_arccos x = casADi__MX__arccos (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__arctan" c_CasADi__MX__arctan
  :: Ptr MX' -> IO (Ptr MX')
casADi__MX__arctan
  :: MX -> IO MX
casADi__MX__arctan x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__MX__arctan x0' >>= wrapReturn

-- classy wrapper
mx_arctan :: MXClass a => a -> IO MX
mx_arctan x = casADi__MX__arctan (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__floor" c_CasADi__MX__floor
  :: Ptr MX' -> IO (Ptr MX')
casADi__MX__floor
  :: MX -> IO MX
casADi__MX__floor x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__MX__floor x0' >>= wrapReturn

-- classy wrapper
mx_floor :: MXClass a => a -> IO MX
mx_floor x = casADi__MX__floor (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__ceil" c_CasADi__MX__ceil
  :: Ptr MX' -> IO (Ptr MX')
casADi__MX__ceil
  :: MX -> IO MX
casADi__MX__ceil x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__MX__ceil x0' >>= wrapReturn

-- classy wrapper
mx_ceil :: MXClass a => a -> IO MX
mx_ceil x = casADi__MX__ceil (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__fabs" c_CasADi__MX__fabs
  :: Ptr MX' -> IO (Ptr MX')
casADi__MX__fabs
  :: MX -> IO MX
casADi__MX__fabs x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__MX__fabs x0' >>= wrapReturn

-- classy wrapper
mx_fabs :: MXClass a => a -> IO MX
mx_fabs x = casADi__MX__fabs (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__sign" c_CasADi__MX__sign
  :: Ptr MX' -> IO (Ptr MX')
casADi__MX__sign
  :: MX -> IO MX
casADi__MX__sign x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__MX__sign x0' >>= wrapReturn

-- classy wrapper
mx_sign :: MXClass a => a -> IO MX
mx_sign x = casADi__MX__sign (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__erfinv" c_CasADi__MX__erfinv
  :: Ptr MX' -> IO (Ptr MX')
casADi__MX__erfinv
  :: MX -> IO MX
casADi__MX__erfinv x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__MX__erfinv x0' >>= wrapReturn

-- classy wrapper
mx_erfinv :: MXClass a => a -> IO MX
mx_erfinv x = casADi__MX__erfinv (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__erf" c_CasADi__MX__erf
  :: Ptr MX' -> IO (Ptr MX')
casADi__MX__erf
  :: MX -> IO MX
casADi__MX__erf x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__MX__erf x0' >>= wrapReturn

-- classy wrapper
mx_erf :: MXClass a => a -> IO MX
mx_erf x = casADi__MX__erf (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__sinh" c_CasADi__MX__sinh
  :: Ptr MX' -> IO (Ptr MX')
casADi__MX__sinh
  :: MX -> IO MX
casADi__MX__sinh x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__MX__sinh x0' >>= wrapReturn

-- classy wrapper
mx_sinh :: MXClass a => a -> IO MX
mx_sinh x = casADi__MX__sinh (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__cosh" c_CasADi__MX__cosh
  :: Ptr MX' -> IO (Ptr MX')
casADi__MX__cosh
  :: MX -> IO MX
casADi__MX__cosh x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__MX__cosh x0' >>= wrapReturn

-- classy wrapper
mx_cosh :: MXClass a => a -> IO MX
mx_cosh x = casADi__MX__cosh (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__tanh" c_CasADi__MX__tanh
  :: Ptr MX' -> IO (Ptr MX')
casADi__MX__tanh
  :: MX -> IO MX
casADi__MX__tanh x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__MX__tanh x0' >>= wrapReturn

-- classy wrapper
mx_tanh :: MXClass a => a -> IO MX
mx_tanh x = casADi__MX__tanh (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__arcsinh" c_CasADi__MX__arcsinh
  :: Ptr MX' -> IO (Ptr MX')
casADi__MX__arcsinh
  :: MX -> IO MX
casADi__MX__arcsinh x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__MX__arcsinh x0' >>= wrapReturn

-- classy wrapper
mx_arcsinh :: MXClass a => a -> IO MX
mx_arcsinh x = casADi__MX__arcsinh (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__arccosh" c_CasADi__MX__arccosh
  :: Ptr MX' -> IO (Ptr MX')
casADi__MX__arccosh
  :: MX -> IO MX
casADi__MX__arccosh x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__MX__arccosh x0' >>= wrapReturn

-- classy wrapper
mx_arccosh :: MXClass a => a -> IO MX
mx_arccosh x = casADi__MX__arccosh (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__arctanh" c_CasADi__MX__arctanh
  :: Ptr MX' -> IO (Ptr MX')
casADi__MX__arctanh
  :: MX -> IO MX
casADi__MX__arctanh x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__MX__arctanh x0' >>= wrapReturn

-- classy wrapper
mx_arctanh :: MXClass a => a -> IO MX
mx_arctanh x = casADi__MX__arctanh (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__logic_not" c_CasADi__MX__logic_not
  :: Ptr MX' -> IO (Ptr MX')
casADi__MX__logic_not
  :: MX -> IO MX
casADi__MX__logic_not x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__MX__logic_not x0' >>= wrapReturn

-- classy wrapper
mx_logic_not :: MXClass a => a -> IO MX
mx_logic_not x = casADi__MX__logic_not (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__attachAssert" c_CasADi__MX__attachAssert
  :: Ptr MX' -> Ptr MX' -> Ptr StdString' -> IO (Ptr MX')
casADi__MX__attachAssert
  :: MX -> MX -> String -> IO MX
casADi__MX__attachAssert x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__MX__attachAssert x0' x1' x2' >>= wrapReturn

-- classy wrapper
{-|
>returns itself, but with an assertion attached
>
>If y does not evaluate to 1, a runtime error is raised
-}
mx_attachAssert :: MXClass a => a -> MX -> String -> IO MX
mx_attachAssert x = casADi__MX__attachAssert (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__attachAssert_TIC" c_CasADi__MX__attachAssert_TIC
  :: Ptr MX' -> Ptr MX' -> IO (Ptr MX')
casADi__MX__attachAssert'
  :: MX -> MX -> IO MX
casADi__MX__attachAssert' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__MX__attachAssert_TIC x0' x1' >>= wrapReturn

-- classy wrapper
mx_attachAssert' :: MXClass a => a -> MX -> IO MX
mx_attachAssert' x = casADi__MX__attachAssert' (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__setSparse" c_CasADi__MX__setSparse
  :: Ptr MX' -> Ptr Sparsity' -> CInt -> IO (Ptr MX')
casADi__MX__setSparse
  :: MX -> Sparsity -> Bool -> IO MX
casADi__MX__setSparse x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__MX__setSparse x0' x1' x2' >>= wrapReturn

-- classy wrapper
{-|
>Set sparse.
-}
mx_setSparse :: MXClass a => a -> Sparsity -> Bool -> IO MX
mx_setSparse x = casADi__MX__setSparse (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__setSparse_TIC" c_CasADi__MX__setSparse_TIC
  :: Ptr MX' -> Ptr Sparsity' -> IO (Ptr MX')
casADi__MX__setSparse'
  :: MX -> Sparsity -> IO MX
casADi__MX__setSparse' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__MX__setSparse_TIC x0' x1' >>= wrapReturn

-- classy wrapper
mx_setSparse' :: MXClass a => a -> Sparsity -> IO MX
mx_setSparse' x = casADi__MX__setSparse' (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__densify" c_CasADi__MX__densify
  :: Ptr MX' -> Ptr MX' -> IO ()
casADi__MX__densify
  :: MX -> MX -> IO ()
casADi__MX__densify x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__MX__densify x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>Make the matrix dense.
-}
mx_densify :: MXClass a => a -> MX -> IO ()
mx_densify x = casADi__MX__densify (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__densify_TIC" c_CasADi__MX__densify_TIC
  :: Ptr MX' -> IO ()
casADi__MX__densify'
  :: MX -> IO ()
casADi__MX__densify' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__MX__densify_TIC x0' >>= wrapReturn

-- classy wrapper
mx_densify' :: MXClass a => a -> IO ()
mx_densify' x = casADi__MX__densify' (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__lift" c_CasADi__MX__lift
  :: Ptr MX' -> Ptr MX' -> IO ()
casADi__MX__lift
  :: MX -> MX -> IO ()
casADi__MX__lift x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__MX__lift x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>Lift an expression.
-}
mx_lift :: MXClass a => a -> MX -> IO ()
mx_lift x = casADi__MX__lift (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__addToSum" c_CasADi__MX__addToSum
  :: Ptr MX' -> Ptr MX' -> IO ()
casADi__MX__addToSum
  :: MX -> MX -> IO ()
casADi__MX__addToSum x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__MX__addToSum x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>Add an expression to the expression if the expression is non-empty,
>otherwise assign.
-}
mx_addToSum :: MXClass a => a -> MX -> IO ()
mx_addToSum x = casADi__MX__addToSum (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__trans" c_CasADi__MX__trans
  :: Ptr MX' -> IO (Ptr MX')
casADi__MX__trans
  :: MX -> IO MX
casADi__MX__trans x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__MX__trans x0' >>= wrapReturn

-- classy wrapper
{-|
>Transpose the matrix.
-}
mx_trans :: MXClass a => a -> IO MX
mx_trans x = casADi__MX__trans (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__mapping" c_CasADi__MX__mapping
  :: Ptr MX' -> IO (Ptr IMatrix')
casADi__MX__mapping
  :: MX -> IO IMatrix
casADi__MX__mapping x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__MX__mapping x0' >>= wrapReturn

-- classy wrapper
{-|
>Get an IMatrix representation of a GetNonzeros or SetNonzeros node.
-}
mx_mapping :: MXClass a => a -> IO IMatrix
mx_mapping x = casADi__MX__mapping (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__setMaxNumCallsInPrint" c_CasADi__MX__setMaxNumCallsInPrint
  :: CLong -> IO ()
casADi__MX__setMaxNumCallsInPrint
  :: Int -> IO ()
casADi__MX__setMaxNumCallsInPrint x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__MX__setMaxNumCallsInPrint x0' >>= wrapReturn

-- classy wrapper
mx_setMaxNumCallsInPrint :: Int -> IO ()
mx_setMaxNumCallsInPrint = casADi__MX__setMaxNumCallsInPrint


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__setMaxNumCallsInPrint_TIC" c_CasADi__MX__setMaxNumCallsInPrint_TIC
  :: IO ()
casADi__MX__setMaxNumCallsInPrint'
  :: IO ()
casADi__MX__setMaxNumCallsInPrint'  =
  c_CasADi__MX__setMaxNumCallsInPrint_TIC  >>= wrapReturn

-- classy wrapper
mx_setMaxNumCallsInPrint' :: IO ()
mx_setMaxNumCallsInPrint' = casADi__MX__setMaxNumCallsInPrint'


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__getMaxNumCallsInPrint" c_CasADi__MX__getMaxNumCallsInPrint
  :: IO CLong
casADi__MX__getMaxNumCallsInPrint
  :: IO Int
casADi__MX__getMaxNumCallsInPrint  =
  c_CasADi__MX__getMaxNumCallsInPrint  >>= wrapReturn

-- classy wrapper
mx_getMaxNumCallsInPrint :: IO Int
mx_getMaxNumCallsInPrint = casADi__MX__getMaxNumCallsInPrint


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__setEqualityCheckingDepth" c_CasADi__MX__setEqualityCheckingDepth
  :: CInt -> IO ()
casADi__MX__setEqualityCheckingDepth
  :: Int -> IO ()
casADi__MX__setEqualityCheckingDepth x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__MX__setEqualityCheckingDepth x0' >>= wrapReturn

-- classy wrapper
mx_setEqualityCheckingDepth :: Int -> IO ()
mx_setEqualityCheckingDepth = casADi__MX__setEqualityCheckingDepth


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__setEqualityCheckingDepth_TIC" c_CasADi__MX__setEqualityCheckingDepth_TIC
  :: IO ()
casADi__MX__setEqualityCheckingDepth'
  :: IO ()
casADi__MX__setEqualityCheckingDepth'  =
  c_CasADi__MX__setEqualityCheckingDepth_TIC  >>= wrapReturn

-- classy wrapper
mx_setEqualityCheckingDepth' :: IO ()
mx_setEqualityCheckingDepth' = casADi__MX__setEqualityCheckingDepth'


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__getEqualityCheckingDepth" c_CasADi__MX__getEqualityCheckingDepth
  :: IO CInt
casADi__MX__getEqualityCheckingDepth
  :: IO Int
casADi__MX__getEqualityCheckingDepth  =
  c_CasADi__MX__getEqualityCheckingDepth  >>= wrapReturn

-- classy wrapper
mx_getEqualityCheckingDepth :: IO Int
mx_getEqualityCheckingDepth = casADi__MX__getEqualityCheckingDepth


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__MX" c_CasADi__MX__MX
  :: IO (Ptr MX')
casADi__MX__MX
  :: IO MX
casADi__MX__MX  =
  c_CasADi__MX__MX  >>= wrapReturn

-- classy wrapper
{-|
>>  CasADi::MX::MX(const std::string &name, int nrow=1, int ncol=1)
>
>>  CasADi::MX::MX(const std::string &name, const std::pair< int, int > &rc)
>
>>  CasADi::MX::MX(const std::string &name, const Sparsity &sp)
>
>>  CasADi::MX::MX(int nrow, int ncol)
>
>>  CasADi::MX::MX(int nrow, int ncol, const MX &val)
>------------------------------------------------------------------------
>
>[DEPRECATED]
>
>>  CasADi::MX::MX(const Sparsity &sp, int val=0)
>
>>  CasADi::MX::MX(const Sparsity &sp, double val)
>
>>  CasADi::MX::MX(const Sparsity &sp, const MX &val)
>------------------------------------------------------------------------
>
>Construct constant matrix with a given sparsity.
>
>>  CasADi::MX::MX()
>------------------------------------------------------------------------
>
>Default constructor.
>
>>  CasADi::MX::MX(double x)
>------------------------------------------------------------------------
>
>Create scalar constant (also implicit type conversion)
>
>>  CasADi::MX::MX(const MX &x)
>------------------------------------------------------------------------
>
>Copy constructor.
>
>>  CasADi::MX::MX(const std::vector< double > &x)
>------------------------------------------------------------------------
>
>Create vector constant (also implicit type conversion)
>
>>  CasADi::MX::MX(const Matrix< double > &x)
>------------------------------------------------------------------------
>
>Create sparse matrix constant (also implicit type conversion)
-}
mx :: IO MX
mx = casADi__MX__MX


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__MX_TIC" c_CasADi__MX__MX_TIC
  :: Ptr Sparsity' -> CInt -> IO (Ptr MX')
casADi__MX__MX'
  :: Sparsity -> Int -> IO MX
casADi__MX__MX' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__MX__MX_TIC x0' x1' >>= wrapReturn

-- classy wrapper
mx' :: Sparsity -> Int -> IO MX
mx' = casADi__MX__MX'


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__MX_TIC_TIC" c_CasADi__MX__MX_TIC_TIC
  :: Ptr Sparsity' -> IO (Ptr MX')
casADi__MX__MX''
  :: Sparsity -> IO MX
casADi__MX__MX'' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__MX__MX_TIC_TIC x0' >>= wrapReturn

-- classy wrapper
mx'' :: Sparsity -> IO MX
mx'' = casADi__MX__MX''


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__MX_TIC_TIC_TIC" c_CasADi__MX__MX_TIC_TIC_TIC
  :: Ptr Sparsity' -> CDouble -> IO (Ptr MX')
casADi__MX__MX'''
  :: Sparsity -> Double -> IO MX
casADi__MX__MX''' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__MX__MX_TIC_TIC_TIC x0' x1' >>= wrapReturn

-- classy wrapper
mx''' :: Sparsity -> Double -> IO MX
mx''' = casADi__MX__MX'''


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__MX_TIC_TIC_TIC_TIC" c_CasADi__MX__MX_TIC_TIC_TIC_TIC
  :: Ptr Sparsity' -> Ptr MX' -> IO (Ptr MX')
casADi__MX__MX''''
  :: Sparsity -> MX -> IO MX
casADi__MX__MX'''' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__MX__MX_TIC_TIC_TIC_TIC x0' x1' >>= wrapReturn

-- classy wrapper
mx'''' :: Sparsity -> MX -> IO MX
mx'''' = casADi__MX__MX''''


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC" c_CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC
  :: CDouble -> IO (Ptr MX')
casADi__MX__MX'''''
  :: Double -> IO MX
casADi__MX__MX''''' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC x0' >>= wrapReturn

-- classy wrapper
mx''''' :: Double -> IO MX
mx''''' = casADi__MX__MX'''''


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC_TIC
  :: Ptr MX' -> IO (Ptr MX')
casADi__MX__MX''''''
  :: MX -> IO MX
casADi__MX__MX'''''' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC_TIC x0' >>= wrapReturn

-- classy wrapper
mx'''''' :: MX -> IO MX
mx'''''' = casADi__MX__MX''''''


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC_TIC_TIC
  :: Ptr (CppVec CDouble) -> IO (Ptr MX')
casADi__MX__MX'''''''
  :: Vector Double -> IO MX
casADi__MX__MX''''''' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' >>= wrapReturn

-- classy wrapper
mx''''''' :: Vector Double -> IO MX
mx''''''' = casADi__MX__MX'''''''


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC
  :: Ptr DMatrix' -> IO (Ptr MX')
casADi__MX__MX''''''''
  :: DMatrix -> IO MX
casADi__MX__MX'''''''' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' >>= wrapReturn

-- classy wrapper
mx'''''''' :: DMatrix -> IO MX
mx'''''''' = casADi__MX__MX''''''''