casadi-bindings-1.8.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''''''''',
         mx'''''''''',
         mx''''''''''',
         mx'''''''''''',
         mx___add__,
         mx___constpow__,
         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_append,
         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_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_getName,
         mx_getNdeps,
         mx_getNumOutputs,
         mx_getOp,
         mx_getOutput,
         mx_getOutput',
         mx_getTemp,
         mx_getValue,
         mx_if_else_zero,
         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_isMultiplication,
         mx_isNorm,
         mx_isOperation,
         mx_isSymbolic,
         mx_isUnary,
         mx_lift,
         mx_log,
         mx_log10,
         mx_logic_and,
         mx_logic_not,
         mx_logic_or,
         mx_makeDense,
         mx_makeDense',
         mx_mul,
         mx_mul',
         mx_mul_full,
         mx_mul_full',
         mx_nan,
         mx_nan',
         mx_nan'',
         mx_nan''',
         mx_numel,
         mx_ones,
         mx_ones',
         mx_ones'',
         mx_operator_minus,
         mx_outer_prod,
         mx_printme,
         mx_repmat,
         mx_repmat',
         mx_setEqualityCheckingDepth,
         mx_setEqualityCheckingDepth',
         mx_setMaxNumCallsInPrint,
         mx_setMaxNumCallsInPrint',
         mx_setSparse,
         mx_setSparse',
         mx_setTemp,
         mx_sign,
         mx_sin,
         mx_sinh,
         mx_size,
         mx_size1,
         mx_size2,
         mx_sparse,
         mx_sparse',
         mx_sparsityRef,
         mx_sqrt,
         mx_tan,
         mx_tanh,
         mx_unary,
         mx_zeros,
         mx_zeros',
         mx_zeros'',
       ) 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.ForeignToolsInstances ( )
import Casadi.Wrappers.Deleters
import Casadi.Wrappers.Data
import Casadi.Wrappers.Enums
import Casadi.MarshalTypes ( CppVec, CppVecVec, CppVecVecVec,
                             StdString', CppBool' ) -- StdOstream'
import Casadi.Marshal ( CornerCase(..), Marshal(..) )
import Casadi.WrapReturn ( WrapReturn(..) )

instance Show MX where
  show = unsafePerformIO . printableObject_getDescription
-- direct wrapper
foreign import ccall unsafe "CasADi__MX__size1" c_CasADi__MX__size1
  :: Ptr MX' -> IO CInt
casADi__MX__size1
  :: MX -> IO Int
casADi__MX__size1 x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__MX__size1 x0' >>= wrapReturn

-- classy wrapper
mx_size1 :: MXClass a => a -> IO Int
mx_size1 x = casADi__MX__size1 (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__size2" c_CasADi__MX__size2
  :: Ptr MX' -> IO CInt
casADi__MX__size2
  :: MX -> IO Int
casADi__MX__size2 x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__MX__size2 x0' >>= wrapReturn

-- classy wrapper
mx_size2 :: MXClass a => a -> IO Int
mx_size2 x = casADi__MX__size2 (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__size" c_CasADi__MX__size
  :: Ptr MX' -> IO CInt
casADi__MX__size
  :: MX -> IO Int
casADi__MX__size x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__MX__size x0' >>= wrapReturn

-- classy wrapper
mx_size :: MXClass a => a -> IO Int
mx_size x = casADi__MX__size (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__numel" c_CasADi__MX__numel
  :: Ptr MX' -> IO CInt
casADi__MX__numel
  :: MX -> IO Int
casADi__MX__numel x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__MX__numel x0' >>= wrapReturn

-- classy wrapper
mx_numel :: MXClass a => a -> IO Int
mx_numel x = casADi__MX__numel (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX____nonzero__" c_CasADi__MX____nonzero__
  :: Ptr MX' -> IO (Ptr CppBool')
casADi__MX____nonzero__
  :: MX -> IO Bool
casADi__MX____nonzero__ x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__MX____nonzero__ x0' >>= (newForeignPtr c_delete_bool) >>= 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__sparsityRef" c_CasADi__MX__sparsityRef
  :: Ptr MX' -> IO (Ptr CRSSparsity')
casADi__MX__sparsityRef
  :: MX -> IO CRSSparsity
casADi__MX__sparsityRef x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__MX__sparsityRef x0' >>= (newForeignPtr c_delete_CasADi__CRSSparsity) >>= wrapReturn

-- classy wrapper
{-|
>Access the sparsity, make a copy if there are multiple references to it.
-}
mx_sparsityRef :: MXClass a => a -> IO CRSSparsity
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' >>= (newForeignPtr c_delete_CasADi__MX) >>= 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' >>= (newForeignPtr c_delete_CasADi__MX) >>= 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' >>= (newForeignPtr c_delete_CasADi__MX) >>= 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' >>= (newForeignPtr c_delete_CasADi__MX) >>= 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' >>= (newForeignPtr c_delete_CasADi__MX) >>= 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 SX.
-}
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' >>= (newForeignPtr c_delete_std__string) >>= 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' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= 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 (Ptr CppBool')
casADi__MX__isSymbolic
  :: MX -> IO Bool
casADi__MX__isSymbolic x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__MX__isSymbolic x0' >>= (newForeignPtr c_delete_bool) >>= 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 (Ptr CppBool')
casADi__MX__isConstant
  :: MX -> IO Bool
casADi__MX__isConstant x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__MX__isConstant x0' >>= (newForeignPtr c_delete_bool) >>= 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 (Ptr CppBool')
casADi__MX__isEvaluation
  :: MX -> IO Bool
casADi__MX__isEvaluation x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__MX__isEvaluation x0' >>= (newForeignPtr c_delete_bool) >>= 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 (Ptr CppBool')
casADi__MX__isEvaluationOutput
  :: MX -> IO Bool
casADi__MX__isEvaluationOutput x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__MX__isEvaluationOutput x0' >>= (newForeignPtr c_delete_bool) >>= 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 (Ptr CppBool')
casADi__MX__isOperation
  :: MX -> Int -> IO Bool
casADi__MX__isOperation x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__MX__isOperation x0' x1' >>= (newForeignPtr c_delete_bool) >>= 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 (Ptr CppBool')
casADi__MX__isMultiplication
  :: MX -> IO Bool
casADi__MX__isMultiplication x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__MX__isMultiplication x0' >>= (newForeignPtr c_delete_bool) >>= 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 (Ptr CppBool')
casADi__MX__isCommutative
  :: MX -> IO Bool
casADi__MX__isCommutative x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__MX__isCommutative x0' >>= (newForeignPtr c_delete_bool) >>= 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 (Ptr CppBool')
casADi__MX__isNorm
  :: MX -> IO Bool
casADi__MX__isNorm x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__MX__isNorm x0' >>= (newForeignPtr c_delete_bool) >>= 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__getFunction" c_CasADi__MX__getFunction
  :: Ptr MX' -> IO (Ptr FX')
casADi__MX__getFunction
  :: MX -> IO FX
casADi__MX__getFunction x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__MX__getFunction x0' >>= (newForeignPtr c_delete_CasADi__FX) >>= wrapReturn

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


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__isBinary" c_CasADi__MX__isBinary
  :: Ptr MX' -> IO (Ptr CppBool')
casADi__MX__isBinary
  :: MX -> IO Bool
casADi__MX__isBinary x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__MX__isBinary x0' >>= (newForeignPtr c_delete_bool) >>= 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 (Ptr CppBool')
casADi__MX__isUnary
  :: MX -> IO Bool
casADi__MX__isUnary x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__MX__isUnary x0' >>= (newForeignPtr c_delete_bool) >>= 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 (Ptr CppBool')
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' >>= (newForeignPtr c_delete_bool) >>= 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
-}
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 (Ptr CppBool')
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' >>= (newForeignPtr c_delete_bool) >>= 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
{-|
>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
{-|
>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' >>= (newForeignPtr c_delete_CasADi__MX) >>= 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' >>= (newForeignPtr c_delete_CasADi__MX) >>= 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__sparse" c_CasADi__MX__sparse
  :: CInt -> CInt -> IO (Ptr MX')
casADi__MX__sparse
  :: Int -> Int -> IO MX
casADi__MX__sparse x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__MX__sparse x0' x1' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn

-- classy wrapper
{-|
>Sparse matrix of all zeros.
-}
mx_sparse :: Int -> Int -> IO MX
mx_sparse = casADi__MX__sparse


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__sparse_TIC" c_CasADi__MX__sparse_TIC
  :: CInt -> IO (Ptr MX')
casADi__MX__sparse'
  :: Int -> IO MX
casADi__MX__sparse' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__MX__sparse_TIC x0' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn

-- classy wrapper
mx_sparse' :: Int -> IO MX
mx_sparse' = casADi__MX__sparse'


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__zeros" c_CasADi__MX__zeros
  :: Ptr CRSSparsity' -> IO (Ptr MX')
casADi__MX__zeros
  :: CRSSparsity -> IO MX
casADi__MX__zeros x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__MX__zeros x0' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn

-- classy wrapper
{-|
>Dense matrix of all zeros.
-}
mx_zeros :: CRSSparsity -> IO MX
mx_zeros = casADi__MX__zeros


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__zeros_TIC" c_CasADi__MX__zeros_TIC
  :: CInt -> CInt -> IO (Ptr MX')
casADi__MX__zeros'
  :: Int -> Int -> IO MX
casADi__MX__zeros' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__MX__zeros_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn

-- classy wrapper
mx_zeros' :: Int -> Int -> IO MX
mx_zeros' = casADi__MX__zeros'


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__zeros_TIC_TIC" c_CasADi__MX__zeros_TIC_TIC
  :: CInt -> IO (Ptr MX')
casADi__MX__zeros''
  :: Int -> IO MX
casADi__MX__zeros'' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__MX__zeros_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn

-- classy wrapper
mx_zeros'' :: Int -> IO MX
mx_zeros'' = casADi__MX__zeros''


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__ones" c_CasADi__MX__ones
  :: Ptr CRSSparsity' -> IO (Ptr MX')
casADi__MX__ones
  :: CRSSparsity -> IO MX
casADi__MX__ones x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__MX__ones x0' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn

-- classy wrapper
{-|
>Matrix of all ones.
-}
mx_ones :: CRSSparsity -> IO MX
mx_ones = casADi__MX__ones


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__ones_TIC" c_CasADi__MX__ones_TIC
  :: CInt -> CInt -> IO (Ptr MX')
casADi__MX__ones'
  :: Int -> Int -> IO MX
casADi__MX__ones' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__MX__ones_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn

-- classy wrapper
mx_ones' :: Int -> Int -> IO MX
mx_ones' = casADi__MX__ones'


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__ones_TIC_TIC" c_CasADi__MX__ones_TIC_TIC
  :: CInt -> IO (Ptr MX')
casADi__MX__ones''
  :: Int -> IO MX
casADi__MX__ones'' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__MX__ones_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn

-- classy wrapper
mx_ones'' :: Int -> IO MX
mx_ones'' = casADi__MX__ones''


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

-- classy wrapper
{-|
>create a matrix with all inf
-}
mx_inf :: CRSSparsity -> 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' >>= (newForeignPtr c_delete_CasADi__MX) >>= 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' >>= (newForeignPtr c_delete_CasADi__MX) >>= 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  >>= (newForeignPtr c_delete_CasADi__MX) >>= 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 CRSSparsity' -> IO (Ptr MX')
casADi__MX__nan
  :: CRSSparsity -> IO MX
casADi__MX__nan x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__MX__nan x0' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn

-- classy wrapper
{-|
>create a matrix with all nan
-}
mx_nan :: CRSSparsity -> 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' >>= (newForeignPtr c_delete_CasADi__MX) >>= 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' >>= (newForeignPtr c_delete_CasADi__MX) >>= 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  >>= (newForeignPtr c_delete_CasADi__MX) >>= 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' -> 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 x0' x1' x2' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn

-- classy wrapper
{-|
>create a matrix by repeating an existing matrix
-}
mx_repmat :: MX -> Int -> Int -> 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 -> 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 x0' x1' >>= (newForeignPtr c_delete_CasADi__MX) >>= 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' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn

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


-- 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' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn

-- classy wrapper
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' >>= (newForeignPtr c_delete_CasADi__MX) >>= 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__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 to the end.
-}
mx_append :: MXClass a => a -> MX -> IO ()
mx_append x = casADi__MX__append (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' >>= (newForeignPtr c_delete_CasADi__MX) >>= 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' >>= (newForeignPtr c_delete_CasADi__MX) >>= 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' >>= (newForeignPtr c_delete_CasADi__MX) >>= 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' >>= (newForeignPtr c_delete_CasADi__MX) >>= 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' >>= (newForeignPtr c_delete_CasADi__MX) >>= 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' >>= (newForeignPtr c_delete_CasADi__MX) >>= 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' >>= (newForeignPtr c_delete_CasADi__MX) >>= 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' >>= (newForeignPtr c_delete_CasADi__MX) >>= 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' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn

-- classy wrapper
{-|
>Division (with future.division in effect)
-}
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' >>= (newForeignPtr c_delete_CasADi__MX) >>= 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' >>= (newForeignPtr c_delete_CasADi__MX) >>= 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' >>= (newForeignPtr c_delete_CasADi__MX) >>= 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' >>= (newForeignPtr c_delete_CasADi__MX) >>= 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 CRSSparsity' -> IO (Ptr MX')
casADi__MX__mul
  :: MX -> MX -> CRSSparsity -> IO MX
casADi__MX__mul x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__MX__mul x0' x1' x2' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn

-- classy wrapper
mx_mul :: MXClass a => a -> MX -> CRSSparsity -> 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' >>= (newForeignPtr c_delete_CasADi__MX) >>= 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 CRSSparsity' -> IO (Ptr MX')
casADi__MX__mul_full
  :: MX -> MX -> CRSSparsity -> 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' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn

-- classy wrapper
mx_mul_full :: MXClass a => a -> MX -> CRSSparsity -> 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' >>= (newForeignPtr c_delete_CasADi__MX) >>= 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' >>= (newForeignPtr c_delete_CasADi__MX) >>= 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' >>= (newForeignPtr c_delete_CasADi__MX) >>= 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' >>= (newForeignPtr c_delete_CasADi__MX) >>= 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' >>= (newForeignPtr c_delete_CasADi__MX) >>= 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' >>= (newForeignPtr c_delete_CasADi__MX) >>= 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' >>= (newForeignPtr c_delete_CasADi__MX) >>= 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' >>= (newForeignPtr c_delete_CasADi__MX) >>= 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' >>= (newForeignPtr c_delete_CasADi__MX) >>= 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' >>= (newForeignPtr c_delete_CasADi__MX) >>= 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' >>= (newForeignPtr c_delete_CasADi__MX) >>= 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__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' >>= (newForeignPtr c_delete_CasADi__MX) >>= 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' >>= (newForeignPtr c_delete_CasADi__MX) >>= 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' >>= (newForeignPtr c_delete_CasADi__MX) >>= 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' >>= (newForeignPtr c_delete_CasADi__MX) >>= 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' >>= (newForeignPtr c_delete_CasADi__MX) >>= 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' >>= (newForeignPtr c_delete_CasADi__MX) >>= 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' >>= (newForeignPtr c_delete_CasADi__MX) >>= 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' >>= (newForeignPtr c_delete_CasADi__MX) >>= 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' >>= (newForeignPtr c_delete_CasADi__MX) >>= 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' >>= (newForeignPtr c_delete_CasADi__MX) >>= 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' >>= (newForeignPtr c_delete_CasADi__MX) >>= 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' >>= (newForeignPtr c_delete_CasADi__MX) >>= 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' >>= (newForeignPtr c_delete_CasADi__MX) >>= 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' >>= (newForeignPtr c_delete_CasADi__MX) >>= 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' >>= (newForeignPtr c_delete_CasADi__MX) >>= 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' >>= (newForeignPtr c_delete_CasADi__MX) >>= 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' >>= (newForeignPtr c_delete_CasADi__MX) >>= 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' >>= (newForeignPtr c_delete_CasADi__MX) >>= 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' >>= (newForeignPtr c_delete_CasADi__MX) >>= 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' >>= (newForeignPtr c_delete_CasADi__MX) >>= 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' >>= (newForeignPtr c_delete_CasADi__MX) >>= 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' >>= (newForeignPtr c_delete_CasADi__MX) >>= 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' >>= (newForeignPtr c_delete_CasADi__MX) >>= 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' >>= (newForeignPtr c_delete_CasADi__MX) >>= 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' >>= (newForeignPtr c_delete_CasADi__MX) >>= 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 CRSSparsity' -> Ptr CppBool' -> IO (Ptr MX')
casADi__MX__setSparse
  :: MX -> CRSSparsity -> 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' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn

-- classy wrapper
{-|
>Set sparse.
-}
mx_setSparse :: MXClass a => a -> CRSSparsity -> 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 CRSSparsity' -> IO (Ptr MX')
casADi__MX__setSparse'
  :: MX -> CRSSparsity -> IO MX
casADi__MX__setSparse' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__MX__setSparse_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn

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


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__makeDense" c_CasADi__MX__makeDense
  :: Ptr MX' -> Ptr MX' -> IO (Ptr MX')
casADi__MX__makeDense
  :: MX -> MX -> IO MX
casADi__MX__makeDense x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__MX__makeDense x0' x1' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn

-- classy wrapper
{-|
>Make dense.
-}
mx_makeDense :: MXClass a => a -> MX -> IO MX
mx_makeDense x = casADi__MX__makeDense (castMX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__makeDense_TIC" c_CasADi__MX__makeDense_TIC
  :: Ptr MX' -> IO (Ptr MX')
casADi__MX__makeDense'
  :: MX -> IO MX
casADi__MX__makeDense' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__MX__makeDense_TIC x0' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn

-- classy wrapper
mx_makeDense' :: MXClass a => a -> IO MX
mx_makeDense' x = casADi__MX__makeDense' (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__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  >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn

-- classy wrapper
{-|
>>  CasADi::MX::MX()
>------------------------------------------------------------------------
>
>Default constructor.
>
>>  CasADi::MX::MX(const std::string &name, int n=1, int m=1)
>
>>  CasADi::MX::MX(const std::string &name, const std::pair< int, int > &nm)
>
>>  CasADi::MX::MX(const std::string &name, const CRSSparsity &sp)
>------------------------------------------------------------------------
>
>Construct a symbolic matrix (matrix variable)
>
>>  CasADi::MX::MX(const CRSSparsity &sp, const MX &val=0)
>------------------------------------------------------------------------
>
>Construct MX with a given sparsity.
>
>>  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)
>
>>  CasADi::MX::MX(int nrow, int ncol)
>------------------------------------------------------------------------
>
>Matrix with all zeros.
>
>>  CasADi::MX::MX(int nrow, int ncol, const MX &val)
>------------------------------------------------------------------------
>
>Dense matrix filled with value val.
-}
mx :: IO MX
mx = casADi__MX__MX


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

-- classy wrapper
mx' :: String -> Int -> 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 StdString' -> CInt -> IO (Ptr MX')
casADi__MX__MX''
  :: String -> Int -> IO MX
casADi__MX__MX'' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__MX__MX_TIC_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn

-- classy wrapper
mx'' :: String -> Int -> 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 StdString' -> IO (Ptr MX')
casADi__MX__MX'''
  :: String -> IO MX
casADi__MX__MX''' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__MX__MX_TIC_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn

-- classy wrapper
mx''' :: String -> 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 StdString' -> Ptr CRSSparsity' -> IO (Ptr MX')
casADi__MX__MX''''
  :: String -> CRSSparsity -> IO MX
casADi__MX__MX'''' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__MX__MX_TIC_TIC_TIC_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn

-- classy wrapper
mx'''' :: String -> CRSSparsity -> 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
  :: Ptr CRSSparsity' -> Ptr MX' -> IO (Ptr MX')
casADi__MX__MX'''''
  :: CRSSparsity -> MX -> IO MX
casADi__MX__MX''''' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn

-- classy wrapper
mx''''' :: CRSSparsity -> MX -> 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 CRSSparsity' -> IO (Ptr MX')
casADi__MX__MX''''''
  :: CRSSparsity -> IO MX
casADi__MX__MX'''''' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn

-- classy wrapper
mx'''''' :: CRSSparsity -> 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
  :: 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_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__MX) >>= 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_TIC_TIC" c_CasADi__MX__MX_TIC_TIC_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_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__MX) >>= 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_TIC_TIC" c_CasADi__MX__MX_TIC_TIC_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_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__MX) >>= 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_TIC_TIC" c_CasADi__MX__MX_TIC_TIC_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_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn

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


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC
  :: CInt -> CInt -> IO (Ptr MX')
casADi__MX__MX'''''''''''
  :: Int -> Int -> IO MX
casADi__MX__MX''''''''''' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn

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


-- direct wrapper
foreign import ccall unsafe "CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC
  :: CInt -> CInt -> Ptr MX' -> IO (Ptr MX')
casADi__MX__MX''''''''''''
  :: Int -> Int -> MX -> IO MX
casADi__MX__MX'''''''''''' x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn

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