{-# OPTIONS_GHC -Wall #-}
{-# OPTIONS_GHC -fno-warn-unused-imports #-}
{-# OPTIONS_GHC -fno-warn-orphans #-}
{-# Language ForeignFunctionInterface #-}
{-# Language FlexibleInstances #-}
{-# Language MultiParamTypeClasses #-}

module Casadi.Wrappers.Classes.SXElement
       (
         SXElement,
         SXElementClass(..),
         sxElement,
         sxElement',
         sxElement___add__,
         sxElement___constpow__,
         sxElement___copysign__,
         sxElement___copysign__',
         sxElement___div__,
         sxElement___eq__,
         sxElement___hash__,
         sxElement___le__,
         sxElement___lt__,
         sxElement___mpower__,
         sxElement___mrdivide__,
         sxElement___mul__,
         sxElement___ne__,
         sxElement___nonzero__,
         sxElement___pow__,
         sxElement___sub__,
         sxElement___truediv__,
         sxElement_arccos,
         sxElement_arccosh,
         sxElement_arcsin,
         sxElement_arcsinh,
         sxElement_arctan,
         sxElement_arctan2,
         sxElement_arctan2',
         sxElement_arctanh,
         sxElement_assignIfDuplicate,
         sxElement_assignIfDuplicate',
         sxElement_binary,
         sxElement_ceil,
         sxElement_constpow,
         sxElement_constpow',
         sxElement_cos,
         sxElement_cosh,
         sxElement_erf,
         sxElement_erfinv,
         sxElement_exp,
         sxElement_fabs,
         sxElement_floor,
         sxElement_fmax,
         sxElement_fmax',
         sxElement_fmin,
         sxElement_fmin',
         sxElement_getDep,
         sxElement_getDep',
         sxElement_getIntValue,
         sxElement_getNdeps,
         sxElement_getOp,
         sxElement_getTemp,
         sxElement_getValue,
         sxElement_hasDep,
         sxElement_if_else_zero,
         sxElement_inv,
         sxElement_isAlmostZero,
         sxElement_isCommutative,
         sxElement_isConstant,
         sxElement_isDoubled,
         sxElement_isEqual,
         sxElement_isEqual',
         sxElement_isInf,
         sxElement_isInteger,
         sxElement_isLeaf,
         sxElement_isMinusInf,
         sxElement_isMinusOne,
         sxElement_isNan,
         sxElement_isNonNegative,
         sxElement_isNull,
         sxElement_isOne,
         sxElement_isOp,
         sxElement_isRegular,
         sxElement_isSymbolic,
         sxElement_isZero,
         sxElement_log,
         sxElement_log10,
         sxElement_logic_and,
         sxElement_logic_not,
         sxElement_logic_or,
         sxElement_mark,
         sxElement_marked,
         sxElement_mul,
         sxElement_operator_minus,
         sxElement_printme,
         sxElement_setTemp,
         sxElement_sign,
         sxElement_sin,
         sxElement_sinh,
         sxElement_sq,
         sxElement_sqrt,
         sxElement_sym,
         sxElement_tan,
         sxElement_tanh,
         sxElement_trans,
         sxElement_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.CToolsInstances ( )
import Casadi.Wrappers.Data
import Casadi.Wrappers.Enums
import Casadi.MarshalTypes ( CppVec, StdString' ) -- StdOstream'
import Casadi.Marshal ( Marshal(..), withMarshal )
import Casadi.WrapReturn ( WrapReturn(..) )

-- direct wrapper
foreign import ccall unsafe "CasADi__SXElement__sym" c_CasADi__SXElement__sym
  :: Ptr StdString' -> IO (Ptr SXElement')
casADi__SXElement__sym
  :: String -> IO SXElement
casADi__SXElement__sym x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SXElement__sym x0' >>= wrapReturn

-- classy wrapper
sxElement_sym :: String -> IO SXElement
sxElement_sym = casADi__SXElement__sym


-- direct wrapper
foreign import ccall unsafe "CasADi__SXElement__binary" c_CasADi__SXElement__binary
  :: CInt -> Ptr SXElement' -> Ptr SXElement' -> IO (Ptr SXElement')
casADi__SXElement__binary
  :: Int -> SXElement -> SXElement -> IO SXElement
casADi__SXElement__binary x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__SXElement__binary x0' x1' x2' >>= wrapReturn

-- classy wrapper
sxElement_binary :: Int -> SXElement -> SXElement -> IO SXElement
sxElement_binary = casADi__SXElement__binary


-- direct wrapper
foreign import ccall unsafe "CasADi__SXElement__unary" c_CasADi__SXElement__unary
  :: CInt -> Ptr SXElement' -> IO (Ptr SXElement')
casADi__SXElement__unary
  :: Int -> SXElement -> IO SXElement
casADi__SXElement__unary x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__SXElement__unary x0' x1' >>= wrapReturn

-- classy wrapper
sxElement_unary :: Int -> SXElement -> IO SXElement
sxElement_unary = casADi__SXElement__unary


-- direct wrapper
foreign import ccall unsafe "CasADi__SXElement____nonzero__" c_CasADi__SXElement____nonzero__
  :: Ptr SXElement' -> IO CInt
casADi__SXElement____nonzero__
  :: SXElement -> IO Bool
casADi__SXElement____nonzero__ x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SXElement____nonzero__ x0' >>= wrapReturn

-- classy wrapper
{-|
>Check the truth value of this node Introduced to catch bool(x) situations in
>python.
-}
sxElement___nonzero__ :: SXElementClass a => a -> IO Bool
sxElement___nonzero__ x = casADi__SXElement____nonzero__ (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXElement__isLeaf" c_CasADi__SXElement__isLeaf
  :: Ptr SXElement' -> IO CInt
casADi__SXElement__isLeaf
  :: SXElement -> IO Bool
casADi__SXElement__isLeaf x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SXElement__isLeaf x0' >>= wrapReturn

-- classy wrapper
{-|
>check if this SXElement is a leaf of the SX graph
>
>An SXElement qualifies as leaf when it has no dependencies.
-}
sxElement_isLeaf :: SXElementClass a => a -> IO Bool
sxElement_isLeaf x = casADi__SXElement__isLeaf (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXElement__isConstant" c_CasADi__SXElement__isConstant
  :: Ptr SXElement' -> IO CInt
casADi__SXElement__isConstant
  :: SXElement -> IO Bool
casADi__SXElement__isConstant x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SXElement__isConstant x0' >>= wrapReturn

-- classy wrapper
sxElement_isConstant :: SXElementClass a => a -> IO Bool
sxElement_isConstant x = casADi__SXElement__isConstant (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXElement__isInteger" c_CasADi__SXElement__isInteger
  :: Ptr SXElement' -> IO CInt
casADi__SXElement__isInteger
  :: SXElement -> IO Bool
casADi__SXElement__isInteger x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SXElement__isInteger x0' >>= wrapReturn

-- classy wrapper
sxElement_isInteger :: SXElementClass a => a -> IO Bool
sxElement_isInteger x = casADi__SXElement__isInteger (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXElement__isSymbolic" c_CasADi__SXElement__isSymbolic
  :: Ptr SXElement' -> IO CInt
casADi__SXElement__isSymbolic
  :: SXElement -> IO Bool
casADi__SXElement__isSymbolic x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SXElement__isSymbolic x0' >>= wrapReturn

-- classy wrapper
sxElement_isSymbolic :: SXElementClass a => a -> IO Bool
sxElement_isSymbolic x = casADi__SXElement__isSymbolic (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXElement__hasDep" c_CasADi__SXElement__hasDep
  :: Ptr SXElement' -> IO CInt
casADi__SXElement__hasDep
  :: SXElement -> IO Bool
casADi__SXElement__hasDep x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SXElement__hasDep x0' >>= wrapReturn

-- classy wrapper
sxElement_hasDep :: SXElementClass a => a -> IO Bool
sxElement_hasDep x = casADi__SXElement__hasDep (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXElement__isCommutative" c_CasADi__SXElement__isCommutative
  :: Ptr SXElement' -> IO CInt
casADi__SXElement__isCommutative
  :: SXElement -> IO Bool
casADi__SXElement__isCommutative x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SXElement__isCommutative x0' >>= wrapReturn

-- classy wrapper
{-|
>Check wether a binary SXElement is commutative.
-}
sxElement_isCommutative :: SXElementClass a => a -> IO Bool
sxElement_isCommutative x = casADi__SXElement__isCommutative (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXElement__isZero" c_CasADi__SXElement__isZero
  :: Ptr SXElement' -> IO CInt
casADi__SXElement__isZero
  :: SXElement -> IO Bool
casADi__SXElement__isZero x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SXElement__isZero x0' >>= wrapReturn

-- classy wrapper
sxElement_isZero :: SXElementClass a => a -> IO Bool
sxElement_isZero x = casADi__SXElement__isZero (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXElement__isAlmostZero" c_CasADi__SXElement__isAlmostZero
  :: Ptr SXElement' -> CDouble -> IO CInt
casADi__SXElement__isAlmostZero
  :: SXElement -> Double -> IO Bool
casADi__SXElement__isAlmostZero x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__SXElement__isAlmostZero x0' x1' >>= wrapReturn

-- classy wrapper
sxElement_isAlmostZero :: SXElementClass a => a -> Double -> IO Bool
sxElement_isAlmostZero x = casADi__SXElement__isAlmostZero (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXElement__isOne" c_CasADi__SXElement__isOne
  :: Ptr SXElement' -> IO CInt
casADi__SXElement__isOne
  :: SXElement -> IO Bool
casADi__SXElement__isOne x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SXElement__isOne x0' >>= wrapReturn

-- classy wrapper
sxElement_isOne :: SXElementClass a => a -> IO Bool
sxElement_isOne x = casADi__SXElement__isOne (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXElement__isMinusOne" c_CasADi__SXElement__isMinusOne
  :: Ptr SXElement' -> IO CInt
casADi__SXElement__isMinusOne
  :: SXElement -> IO Bool
casADi__SXElement__isMinusOne x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SXElement__isMinusOne x0' >>= wrapReturn

-- classy wrapper
sxElement_isMinusOne :: SXElementClass a => a -> IO Bool
sxElement_isMinusOne x = casADi__SXElement__isMinusOne (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXElement__isNan" c_CasADi__SXElement__isNan
  :: Ptr SXElement' -> IO CInt
casADi__SXElement__isNan
  :: SXElement -> IO Bool
casADi__SXElement__isNan x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SXElement__isNan x0' >>= wrapReturn

-- classy wrapper
sxElement_isNan :: SXElementClass a => a -> IO Bool
sxElement_isNan x = casADi__SXElement__isNan (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXElement__isInf" c_CasADi__SXElement__isInf
  :: Ptr SXElement' -> IO CInt
casADi__SXElement__isInf
  :: SXElement -> IO Bool
casADi__SXElement__isInf x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SXElement__isInf x0' >>= wrapReturn

-- classy wrapper
sxElement_isInf :: SXElementClass a => a -> IO Bool
sxElement_isInf x = casADi__SXElement__isInf (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXElement__isMinusInf" c_CasADi__SXElement__isMinusInf
  :: Ptr SXElement' -> IO CInt
casADi__SXElement__isMinusInf
  :: SXElement -> IO Bool
casADi__SXElement__isMinusInf x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SXElement__isMinusInf x0' >>= wrapReturn

-- classy wrapper
sxElement_isMinusInf :: SXElementClass a => a -> IO Bool
sxElement_isMinusInf x = casADi__SXElement__isMinusInf (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXElement__getOp" c_CasADi__SXElement__getOp
  :: Ptr SXElement' -> IO CInt
casADi__SXElement__getOp
  :: SXElement -> IO Int
casADi__SXElement__getOp x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SXElement__getOp x0' >>= wrapReturn

-- classy wrapper
sxElement_getOp :: SXElementClass a => a -> IO Int
sxElement_getOp x = casADi__SXElement__getOp (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXElement__isOp" c_CasADi__SXElement__isOp
  :: Ptr SXElement' -> CInt -> IO CInt
casADi__SXElement__isOp
  :: SXElement -> Int -> IO Bool
casADi__SXElement__isOp x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__SXElement__isOp x0' x1' >>= wrapReturn

-- classy wrapper
sxElement_isOp :: SXElementClass a => a -> Int -> IO Bool
sxElement_isOp x = casADi__SXElement__isOp (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXElement__isRegular" c_CasADi__SXElement__isRegular
  :: Ptr SXElement' -> IO CInt
casADi__SXElement__isRegular
  :: SXElement -> IO Bool
casADi__SXElement__isRegular x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SXElement__isRegular x0' >>= wrapReturn

-- classy wrapper
{-|
>Checks if expression does not contain NaN or Inf.
-}
sxElement_isRegular :: SXElementClass a => a -> IO Bool
sxElement_isRegular x = casADi__SXElement__isRegular (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXElement__isEqual" c_CasADi__SXElement__isEqual
  :: Ptr SXElement' -> Ptr SXElement' -> CInt -> IO CInt
casADi__SXElement__isEqual
  :: SXElement -> SXElement -> Int -> IO Bool
casADi__SXElement__isEqual x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__SXElement__isEqual x0' x1' x2' >>= wrapReturn

-- classy wrapper
{-|
>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
-}
sxElement_isEqual :: SXElementClass a => a -> SXElement -> Int -> IO Bool
sxElement_isEqual x = casADi__SXElement__isEqual (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXElement__isEqual_TIC" c_CasADi__SXElement__isEqual_TIC
  :: Ptr SXElement' -> Ptr SXElement' -> IO CInt
casADi__SXElement__isEqual'
  :: SXElement -> SXElement -> IO Bool
casADi__SXElement__isEqual' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__SXElement__isEqual_TIC x0' x1' >>= wrapReturn

-- classy wrapper
sxElement_isEqual' :: SXElementClass a => a -> SXElement -> IO Bool
sxElement_isEqual' x = casADi__SXElement__isEqual' (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXElement__isNonNegative" c_CasADi__SXElement__isNonNegative
  :: Ptr SXElement' -> IO CInt
casADi__SXElement__isNonNegative
  :: SXElement -> IO Bool
casADi__SXElement__isNonNegative x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SXElement__isNonNegative x0' >>= wrapReturn

-- classy wrapper
{-|
>Check if a value is always nonnegative (false negatives are allowed)
-}
sxElement_isNonNegative :: SXElementClass a => a -> IO Bool
sxElement_isNonNegative x = casADi__SXElement__isNonNegative (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXElement__getValue" c_CasADi__SXElement__getValue
  :: Ptr SXElement' -> IO CDouble
casADi__SXElement__getValue
  :: SXElement -> IO Double
casADi__SXElement__getValue x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SXElement__getValue x0' >>= wrapReturn

-- classy wrapper
sxElement_getValue :: SXElementClass a => a -> IO Double
sxElement_getValue x = casADi__SXElement__getValue (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXElement__getIntValue" c_CasADi__SXElement__getIntValue
  :: Ptr SXElement' -> IO CInt
casADi__SXElement__getIntValue
  :: SXElement -> IO Int
casADi__SXElement__getIntValue x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SXElement__getIntValue x0' >>= wrapReturn

-- classy wrapper
sxElement_getIntValue :: SXElementClass a => a -> IO Int
sxElement_getIntValue x = casADi__SXElement__getIntValue (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXElement__getDep" c_CasADi__SXElement__getDep
  :: Ptr SXElement' -> CInt -> IO (Ptr SXElement')
casADi__SXElement__getDep
  :: SXElement -> Int -> IO SXElement
casADi__SXElement__getDep x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__SXElement__getDep x0' x1' >>= wrapReturn

-- classy wrapper
sxElement_getDep :: SXElementClass a => a -> Int -> IO SXElement
sxElement_getDep x = casADi__SXElement__getDep (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXElement__getDep_TIC" c_CasADi__SXElement__getDep_TIC
  :: Ptr SXElement' -> IO (Ptr SXElement')
casADi__SXElement__getDep'
  :: SXElement -> IO SXElement
casADi__SXElement__getDep' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SXElement__getDep_TIC x0' >>= wrapReturn

-- classy wrapper
sxElement_getDep' :: SXElementClass a => a -> IO SXElement
sxElement_getDep' x = casADi__SXElement__getDep' (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXElement__isDoubled" c_CasADi__SXElement__isDoubled
  :: Ptr SXElement' -> IO CInt
casADi__SXElement__isDoubled
  :: SXElement -> IO Bool
casADi__SXElement__isDoubled x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SXElement__isDoubled x0' >>= wrapReturn

-- classy wrapper
{-|
>Check if the node is the sum of two equal expressions.
-}
sxElement_isDoubled :: SXElementClass a => a -> IO Bool
sxElement_isDoubled x = casADi__SXElement__isDoubled (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXElement__getNdeps" c_CasADi__SXElement__getNdeps
  :: Ptr SXElement' -> IO CInt
casADi__SXElement__getNdeps
  :: SXElement -> IO Int
casADi__SXElement__getNdeps x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SXElement__getNdeps x0' >>= wrapReturn

-- classy wrapper
{-|
>Get the number of dependencies of a binary SXElement.
-}
sxElement_getNdeps :: SXElementClass a => a -> IO Int
sxElement_getNdeps x = casADi__SXElement__getNdeps (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXElement____hash__" c_CasADi__SXElement____hash__
  :: Ptr SXElement' -> IO CLong
casADi__SXElement____hash__
  :: SXElement -> IO Int
casADi__SXElement____hash__ x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SXElement____hash__ x0' >>= wrapReturn

-- classy wrapper
{-|
>Returns a number that is unique for a given SXNode. If the SXElement does
>not point to any node, 0 is returned.
-}
sxElement___hash__ :: SXElementClass a => a -> IO Int
sxElement___hash__ x = casADi__SXElement____hash__ (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXElement__operator_minus" c_CasADi__SXElement__operator_minus
  :: Ptr SXElement' -> IO (Ptr SXElement')
casADi__SXElement__operator_minus
  :: SXElement -> IO SXElement
casADi__SXElement__operator_minus x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SXElement__operator_minus x0' >>= wrapReturn

-- classy wrapper
sxElement_operator_minus :: SXElementClass a => a -> IO SXElement
sxElement_operator_minus x = casADi__SXElement__operator_minus (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXElement____add__" c_CasADi__SXElement____add__
  :: Ptr SXElement' -> Ptr SXElement' -> IO (Ptr SXElement')
casADi__SXElement____add__
  :: SXElement -> SXElement -> IO SXElement
casADi__SXElement____add__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__SXElement____add__ x0' x1' >>= wrapReturn

-- classy wrapper
sxElement___add__ :: SXElementClass a => a -> SXElement -> IO SXElement
sxElement___add__ x = casADi__SXElement____add__ (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXElement____sub__" c_CasADi__SXElement____sub__
  :: Ptr SXElement' -> Ptr SXElement' -> IO (Ptr SXElement')
casADi__SXElement____sub__
  :: SXElement -> SXElement -> IO SXElement
casADi__SXElement____sub__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__SXElement____sub__ x0' x1' >>= wrapReturn

-- classy wrapper
sxElement___sub__ :: SXElementClass a => a -> SXElement -> IO SXElement
sxElement___sub__ x = casADi__SXElement____sub__ (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXElement____mul__" c_CasADi__SXElement____mul__
  :: Ptr SXElement' -> Ptr SXElement' -> IO (Ptr SXElement')
casADi__SXElement____mul__
  :: SXElement -> SXElement -> IO SXElement
casADi__SXElement____mul__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__SXElement____mul__ x0' x1' >>= wrapReturn

-- classy wrapper
sxElement___mul__ :: SXElementClass a => a -> SXElement -> IO SXElement
sxElement___mul__ x = casADi__SXElement____mul__ (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXElement____div__" c_CasADi__SXElement____div__
  :: Ptr SXElement' -> Ptr SXElement' -> IO (Ptr SXElement')
casADi__SXElement____div__
  :: SXElement -> SXElement -> IO SXElement
casADi__SXElement____div__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__SXElement____div__ x0' x1' >>= wrapReturn

-- classy wrapper
sxElement___div__ :: SXElementClass a => a -> SXElement -> IO SXElement
sxElement___div__ x = casADi__SXElement____div__ (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXElement____lt__" c_CasADi__SXElement____lt__
  :: Ptr SXElement' -> Ptr SXElement' -> IO (Ptr SXElement')
casADi__SXElement____lt__
  :: SXElement -> SXElement -> IO SXElement
casADi__SXElement____lt__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__SXElement____lt__ x0' x1' >>= wrapReturn

-- classy wrapper
sxElement___lt__ :: SXElementClass a => a -> SXElement -> IO SXElement
sxElement___lt__ x = casADi__SXElement____lt__ (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXElement____le__" c_CasADi__SXElement____le__
  :: Ptr SXElement' -> Ptr SXElement' -> IO (Ptr SXElement')
casADi__SXElement____le__
  :: SXElement -> SXElement -> IO SXElement
casADi__SXElement____le__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__SXElement____le__ x0' x1' >>= wrapReturn

-- classy wrapper
sxElement___le__ :: SXElementClass a => a -> SXElement -> IO SXElement
sxElement___le__ x = casADi__SXElement____le__ (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXElement____eq__" c_CasADi__SXElement____eq__
  :: Ptr SXElement' -> Ptr SXElement' -> IO (Ptr SXElement')
casADi__SXElement____eq__
  :: SXElement -> SXElement -> IO SXElement
casADi__SXElement____eq__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__SXElement____eq__ x0' x1' >>= wrapReturn

-- classy wrapper
sxElement___eq__ :: SXElementClass a => a -> SXElement -> IO SXElement
sxElement___eq__ x = casADi__SXElement____eq__ (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXElement____ne__" c_CasADi__SXElement____ne__
  :: Ptr SXElement' -> Ptr SXElement' -> IO (Ptr SXElement')
casADi__SXElement____ne__
  :: SXElement -> SXElement -> IO SXElement
casADi__SXElement____ne__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__SXElement____ne__ x0' x1' >>= wrapReturn

-- classy wrapper
sxElement___ne__ :: SXElementClass a => a -> SXElement -> IO SXElement
sxElement___ne__ x = casADi__SXElement____ne__ (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXElement____truediv__" c_CasADi__SXElement____truediv__
  :: Ptr SXElement' -> Ptr SXElement' -> IO (Ptr SXElement')
casADi__SXElement____truediv__
  :: SXElement -> SXElement -> IO SXElement
casADi__SXElement____truediv__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__SXElement____truediv__ x0' x1' >>= wrapReturn

-- classy wrapper
sxElement___truediv__ :: SXElementClass a => a -> SXElement -> IO SXElement
sxElement___truediv__ x = casADi__SXElement____truediv__ (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXElement____pow__" c_CasADi__SXElement____pow__
  :: Ptr SXElement' -> Ptr SXElement' -> IO (Ptr SXElement')
casADi__SXElement____pow__
  :: SXElement -> SXElement -> IO SXElement
casADi__SXElement____pow__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__SXElement____pow__ x0' x1' >>= wrapReturn

-- classy wrapper
sxElement___pow__ :: SXElementClass a => a -> SXElement -> IO SXElement
sxElement___pow__ x = casADi__SXElement____pow__ (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXElement____constpow__" c_CasADi__SXElement____constpow__
  :: Ptr SXElement' -> Ptr SXElement' -> IO (Ptr SXElement')
casADi__SXElement____constpow__
  :: SXElement -> SXElement -> IO SXElement
casADi__SXElement____constpow__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__SXElement____constpow__ x0' x1' >>= wrapReturn

-- classy wrapper
sxElement___constpow__ :: SXElementClass a => a -> SXElement -> IO SXElement
sxElement___constpow__ x = casADi__SXElement____constpow__ (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXElement____mrdivide__" c_CasADi__SXElement____mrdivide__
  :: Ptr SXElement' -> Ptr SXElement' -> IO (Ptr SXElement')
casADi__SXElement____mrdivide__
  :: SXElement -> SXElement -> IO SXElement
casADi__SXElement____mrdivide__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__SXElement____mrdivide__ x0' x1' >>= wrapReturn

-- classy wrapper
sxElement___mrdivide__ :: SXElementClass a => a -> SXElement -> IO SXElement
sxElement___mrdivide__ x = casADi__SXElement____mrdivide__ (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXElement____mpower__" c_CasADi__SXElement____mpower__
  :: Ptr SXElement' -> Ptr SXElement' -> IO (Ptr SXElement')
casADi__SXElement____mpower__
  :: SXElement -> SXElement -> IO SXElement
casADi__SXElement____mpower__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__SXElement____mpower__ x0' x1' >>= wrapReturn

-- classy wrapper
sxElement___mpower__ :: SXElementClass a => a -> SXElement -> IO SXElement
sxElement___mpower__ x = casADi__SXElement____mpower__ (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXElement__trans" c_CasADi__SXElement__trans
  :: Ptr SXElement' -> IO (Ptr SXElement')
casADi__SXElement__trans
  :: SXElement -> IO SXElement
casADi__SXElement__trans x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SXElement__trans x0' >>= wrapReturn

-- classy wrapper
sxElement_trans :: SXElementClass a => a -> IO SXElement
sxElement_trans x = casADi__SXElement__trans (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXElement__mul" c_CasADi__SXElement__mul
  :: Ptr SXElement' -> Ptr SXElement' -> IO (Ptr SXElement')
casADi__SXElement__mul
  :: SXElement -> SXElement -> IO SXElement
casADi__SXElement__mul x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__SXElement__mul x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>The following functions serves two purposes: Numpy compatibility and to
>allow unambigous access.
-}
sxElement_mul :: SXElementClass a => a -> SXElement -> IO SXElement
sxElement_mul x = casADi__SXElement__mul (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXElement__exp" c_CasADi__SXElement__exp
  :: Ptr SXElement' -> IO (Ptr SXElement')
casADi__SXElement__exp
  :: SXElement -> IO SXElement
casADi__SXElement__exp x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SXElement__exp x0' >>= wrapReturn

-- classy wrapper
sxElement_exp :: SXElementClass a => a -> IO SXElement
sxElement_exp x = casADi__SXElement__exp (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXElement__log" c_CasADi__SXElement__log
  :: Ptr SXElement' -> IO (Ptr SXElement')
casADi__SXElement__log
  :: SXElement -> IO SXElement
casADi__SXElement__log x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SXElement__log x0' >>= wrapReturn

-- classy wrapper
sxElement_log :: SXElementClass a => a -> IO SXElement
sxElement_log x = casADi__SXElement__log (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXElement__sqrt" c_CasADi__SXElement__sqrt
  :: Ptr SXElement' -> IO (Ptr SXElement')
casADi__SXElement__sqrt
  :: SXElement -> IO SXElement
casADi__SXElement__sqrt x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SXElement__sqrt x0' >>= wrapReturn

-- classy wrapper
sxElement_sqrt :: SXElementClass a => a -> IO SXElement
sxElement_sqrt x = casADi__SXElement__sqrt (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXElement__sq" c_CasADi__SXElement__sq
  :: Ptr SXElement' -> IO (Ptr SXElement')
casADi__SXElement__sq
  :: SXElement -> IO SXElement
casADi__SXElement__sq x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SXElement__sq x0' >>= wrapReturn

-- classy wrapper
sxElement_sq :: SXElementClass a => a -> IO SXElement
sxElement_sq x = casADi__SXElement__sq (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXElement__sin" c_CasADi__SXElement__sin
  :: Ptr SXElement' -> IO (Ptr SXElement')
casADi__SXElement__sin
  :: SXElement -> IO SXElement
casADi__SXElement__sin x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SXElement__sin x0' >>= wrapReturn

-- classy wrapper
sxElement_sin :: SXElementClass a => a -> IO SXElement
sxElement_sin x = casADi__SXElement__sin (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXElement__cos" c_CasADi__SXElement__cos
  :: Ptr SXElement' -> IO (Ptr SXElement')
casADi__SXElement__cos
  :: SXElement -> IO SXElement
casADi__SXElement__cos x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SXElement__cos x0' >>= wrapReturn

-- classy wrapper
sxElement_cos :: SXElementClass a => a -> IO SXElement
sxElement_cos x = casADi__SXElement__cos (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXElement__tan" c_CasADi__SXElement__tan
  :: Ptr SXElement' -> IO (Ptr SXElement')
casADi__SXElement__tan
  :: SXElement -> IO SXElement
casADi__SXElement__tan x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SXElement__tan x0' >>= wrapReturn

-- classy wrapper
sxElement_tan :: SXElementClass a => a -> IO SXElement
sxElement_tan x = casADi__SXElement__tan (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXElement__arcsin" c_CasADi__SXElement__arcsin
  :: Ptr SXElement' -> IO (Ptr SXElement')
casADi__SXElement__arcsin
  :: SXElement -> IO SXElement
casADi__SXElement__arcsin x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SXElement__arcsin x0' >>= wrapReturn

-- classy wrapper
sxElement_arcsin :: SXElementClass a => a -> IO SXElement
sxElement_arcsin x = casADi__SXElement__arcsin (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXElement__arccos" c_CasADi__SXElement__arccos
  :: Ptr SXElement' -> IO (Ptr SXElement')
casADi__SXElement__arccos
  :: SXElement -> IO SXElement
casADi__SXElement__arccos x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SXElement__arccos x0' >>= wrapReturn

-- classy wrapper
sxElement_arccos :: SXElementClass a => a -> IO SXElement
sxElement_arccos x = casADi__SXElement__arccos (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXElement__arctan" c_CasADi__SXElement__arctan
  :: Ptr SXElement' -> IO (Ptr SXElement')
casADi__SXElement__arctan
  :: SXElement -> IO SXElement
casADi__SXElement__arctan x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SXElement__arctan x0' >>= wrapReturn

-- classy wrapper
sxElement_arctan :: SXElementClass a => a -> IO SXElement
sxElement_arctan x = casADi__SXElement__arctan (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXElement__floor" c_CasADi__SXElement__floor
  :: Ptr SXElement' -> IO (Ptr SXElement')
casADi__SXElement__floor
  :: SXElement -> IO SXElement
casADi__SXElement__floor x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SXElement__floor x0' >>= wrapReturn

-- classy wrapper
sxElement_floor :: SXElementClass a => a -> IO SXElement
sxElement_floor x = casADi__SXElement__floor (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXElement__ceil" c_CasADi__SXElement__ceil
  :: Ptr SXElement' -> IO (Ptr SXElement')
casADi__SXElement__ceil
  :: SXElement -> IO SXElement
casADi__SXElement__ceil x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SXElement__ceil x0' >>= wrapReturn

-- classy wrapper
sxElement_ceil :: SXElementClass a => a -> IO SXElement
sxElement_ceil x = casADi__SXElement__ceil (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXElement__erf" c_CasADi__SXElement__erf
  :: Ptr SXElement' -> IO (Ptr SXElement')
casADi__SXElement__erf
  :: SXElement -> IO SXElement
casADi__SXElement__erf x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SXElement__erf x0' >>= wrapReturn

-- classy wrapper
sxElement_erf :: SXElementClass a => a -> IO SXElement
sxElement_erf x = casADi__SXElement__erf (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXElement__erfinv" c_CasADi__SXElement__erfinv
  :: Ptr SXElement' -> IO (Ptr SXElement')
casADi__SXElement__erfinv
  :: SXElement -> IO SXElement
casADi__SXElement__erfinv x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SXElement__erfinv x0' >>= wrapReturn

-- classy wrapper
sxElement_erfinv :: SXElementClass a => a -> IO SXElement
sxElement_erfinv x = casADi__SXElement__erfinv (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXElement__fabs" c_CasADi__SXElement__fabs
  :: Ptr SXElement' -> IO (Ptr SXElement')
casADi__SXElement__fabs
  :: SXElement -> IO SXElement
casADi__SXElement__fabs x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SXElement__fabs x0' >>= wrapReturn

-- classy wrapper
sxElement_fabs :: SXElementClass a => a -> IO SXElement
sxElement_fabs x = casADi__SXElement__fabs (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXElement__fmin" c_CasADi__SXElement__fmin
  :: Ptr SXElement' -> Ptr SXElement' -> IO (Ptr SXElement')
casADi__SXElement__fmin
  :: SXElement -> SXElement -> IO SXElement
casADi__SXElement__fmin x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__SXElement__fmin x0' x1' >>= wrapReturn

-- classy wrapper
sxElement_fmin :: SXElementClass a => a -> SXElement -> IO SXElement
sxElement_fmin x = casADi__SXElement__fmin (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXElement__fmax" c_CasADi__SXElement__fmax
  :: Ptr SXElement' -> Ptr SXElement' -> IO (Ptr SXElement')
casADi__SXElement__fmax
  :: SXElement -> SXElement -> IO SXElement
casADi__SXElement__fmax x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__SXElement__fmax x0' x1' >>= wrapReturn

-- classy wrapper
sxElement_fmax :: SXElementClass a => a -> SXElement -> IO SXElement
sxElement_fmax x = casADi__SXElement__fmax (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXElement__inv" c_CasADi__SXElement__inv
  :: Ptr SXElement' -> IO (Ptr SXElement')
casADi__SXElement__inv
  :: SXElement -> IO SXElement
casADi__SXElement__inv x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SXElement__inv x0' >>= wrapReturn

-- classy wrapper
sxElement_inv :: SXElementClass a => a -> IO SXElement
sxElement_inv x = casADi__SXElement__inv (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXElement__sinh" c_CasADi__SXElement__sinh
  :: Ptr SXElement' -> IO (Ptr SXElement')
casADi__SXElement__sinh
  :: SXElement -> IO SXElement
casADi__SXElement__sinh x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SXElement__sinh x0' >>= wrapReturn

-- classy wrapper
sxElement_sinh :: SXElementClass a => a -> IO SXElement
sxElement_sinh x = casADi__SXElement__sinh (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXElement__cosh" c_CasADi__SXElement__cosh
  :: Ptr SXElement' -> IO (Ptr SXElement')
casADi__SXElement__cosh
  :: SXElement -> IO SXElement
casADi__SXElement__cosh x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SXElement__cosh x0' >>= wrapReturn

-- classy wrapper
sxElement_cosh :: SXElementClass a => a -> IO SXElement
sxElement_cosh x = casADi__SXElement__cosh (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXElement__tanh" c_CasADi__SXElement__tanh
  :: Ptr SXElement' -> IO (Ptr SXElement')
casADi__SXElement__tanh
  :: SXElement -> IO SXElement
casADi__SXElement__tanh x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SXElement__tanh x0' >>= wrapReturn

-- classy wrapper
sxElement_tanh :: SXElementClass a => a -> IO SXElement
sxElement_tanh x = casADi__SXElement__tanh (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXElement__arcsinh" c_CasADi__SXElement__arcsinh
  :: Ptr SXElement' -> IO (Ptr SXElement')
casADi__SXElement__arcsinh
  :: SXElement -> IO SXElement
casADi__SXElement__arcsinh x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SXElement__arcsinh x0' >>= wrapReturn

-- classy wrapper
sxElement_arcsinh :: SXElementClass a => a -> IO SXElement
sxElement_arcsinh x = casADi__SXElement__arcsinh (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXElement__arccosh" c_CasADi__SXElement__arccosh
  :: Ptr SXElement' -> IO (Ptr SXElement')
casADi__SXElement__arccosh
  :: SXElement -> IO SXElement
casADi__SXElement__arccosh x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SXElement__arccosh x0' >>= wrapReturn

-- classy wrapper
sxElement_arccosh :: SXElementClass a => a -> IO SXElement
sxElement_arccosh x = casADi__SXElement__arccosh (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXElement__arctanh" c_CasADi__SXElement__arctanh
  :: Ptr SXElement' -> IO (Ptr SXElement')
casADi__SXElement__arctanh
  :: SXElement -> IO SXElement
casADi__SXElement__arctanh x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SXElement__arctanh x0' >>= wrapReturn

-- classy wrapper
sxElement_arctanh :: SXElementClass a => a -> IO SXElement
sxElement_arctanh x = casADi__SXElement__arctanh (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXElement__arctan2" c_CasADi__SXElement__arctan2
  :: Ptr SXElement' -> Ptr SXElement' -> IO (Ptr SXElement')
casADi__SXElement__arctan2
  :: SXElement -> SXElement -> IO SXElement
casADi__SXElement__arctan2 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__SXElement__arctan2 x0' x1' >>= wrapReturn

-- classy wrapper
sxElement_arctan2 :: SXElementClass a => a -> SXElement -> IO SXElement
sxElement_arctan2 x = casADi__SXElement__arctan2 (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXElement__log10" c_CasADi__SXElement__log10
  :: Ptr SXElement' -> IO (Ptr SXElement')
casADi__SXElement__log10
  :: SXElement -> IO SXElement
casADi__SXElement__log10 x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SXElement__log10 x0' >>= wrapReturn

-- classy wrapper
sxElement_log10 :: SXElementClass a => a -> IO SXElement
sxElement_log10 x = casADi__SXElement__log10 (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXElement__printme" c_CasADi__SXElement__printme
  :: Ptr SXElement' -> Ptr SXElement' -> IO (Ptr SXElement')
casADi__SXElement__printme
  :: SXElement -> SXElement -> IO SXElement
casADi__SXElement__printme x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__SXElement__printme x0' x1' >>= wrapReturn

-- classy wrapper
sxElement_printme :: SXElementClass a => a -> SXElement -> IO SXElement
sxElement_printme x = casADi__SXElement__printme (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXElement__sign" c_CasADi__SXElement__sign
  :: Ptr SXElement' -> IO (Ptr SXElement')
casADi__SXElement__sign
  :: SXElement -> IO SXElement
casADi__SXElement__sign x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SXElement__sign x0' >>= wrapReturn

-- classy wrapper
sxElement_sign :: SXElementClass a => a -> IO SXElement
sxElement_sign x = casADi__SXElement__sign (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXElement____copysign__" c_CasADi__SXElement____copysign__
  :: Ptr SXElement' -> Ptr SXElement' -> IO (Ptr SXElement')
casADi__SXElement____copysign__
  :: SXElement -> SXElement -> IO SXElement
casADi__SXElement____copysign__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__SXElement____copysign__ x0' x1' >>= wrapReturn

-- classy wrapper
sxElement___copysign__ :: SXElementClass a => a -> SXElement -> IO SXElement
sxElement___copysign__ x = casADi__SXElement____copysign__ (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXElement__constpow" c_CasADi__SXElement__constpow
  :: Ptr SXElement' -> Ptr SXElement' -> IO (Ptr SXElement')
casADi__SXElement__constpow
  :: SXElement -> SXElement -> IO SXElement
casADi__SXElement__constpow x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__SXElement__constpow x0' x1' >>= wrapReturn

-- classy wrapper
sxElement_constpow :: SXElementClass a => a -> SXElement -> IO SXElement
sxElement_constpow x = casADi__SXElement__constpow (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXElement__logic_not" c_CasADi__SXElement__logic_not
  :: Ptr SXElement' -> IO (Ptr SXElement')
casADi__SXElement__logic_not
  :: SXElement -> IO SXElement
casADi__SXElement__logic_not x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SXElement__logic_not x0' >>= wrapReturn

-- classy wrapper
sxElement_logic_not :: SXElementClass a => a -> IO SXElement
sxElement_logic_not x = casADi__SXElement__logic_not (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXElement__logic_and" c_CasADi__SXElement__logic_and
  :: Ptr SXElement' -> Ptr SXElement' -> IO (Ptr SXElement')
casADi__SXElement__logic_and
  :: SXElement -> SXElement -> IO SXElement
casADi__SXElement__logic_and x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__SXElement__logic_and x0' x1' >>= wrapReturn

-- classy wrapper
sxElement_logic_and :: SXElementClass a => a -> SXElement -> IO SXElement
sxElement_logic_and x = casADi__SXElement__logic_and (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXElement__logic_or" c_CasADi__SXElement__logic_or
  :: Ptr SXElement' -> Ptr SXElement' -> IO (Ptr SXElement')
casADi__SXElement__logic_or
  :: SXElement -> SXElement -> IO SXElement
casADi__SXElement__logic_or x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__SXElement__logic_or x0' x1' >>= wrapReturn

-- classy wrapper
sxElement_logic_or :: SXElementClass a => a -> SXElement -> IO SXElement
sxElement_logic_or x = casADi__SXElement__logic_or (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXElement__if_else_zero" c_CasADi__SXElement__if_else_zero
  :: Ptr SXElement' -> Ptr SXElement' -> IO (Ptr SXElement')
casADi__SXElement__if_else_zero
  :: SXElement -> SXElement -> IO SXElement
casADi__SXElement__if_else_zero x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__SXElement__if_else_zero x0' x1' >>= wrapReturn

-- classy wrapper
sxElement_if_else_zero :: SXElementClass a => a -> SXElement -> IO SXElement
sxElement_if_else_zero x = casADi__SXElement__if_else_zero (castSXElement x)


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

-- classy wrapper
sxElement_fmin' :: SXElementClass a => a -> SX -> IO SX
sxElement_fmin' x = casADi__SXElement__fmin' (castSXElement x)


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

-- classy wrapper
sxElement_fmax' :: SXElementClass a => a -> SX -> IO SX
sxElement_fmax' x = casADi__SXElement__fmax' (castSXElement x)


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

-- classy wrapper
sxElement_constpow' :: SXElementClass a => a -> SX -> IO SX
sxElement_constpow' x = casADi__SXElement__constpow' (castSXElement x)


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

-- classy wrapper
sxElement___copysign__' :: SXElementClass a => a -> SX -> IO SX
sxElement___copysign__' x = casADi__SXElement____copysign__' (castSXElement x)


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

-- classy wrapper
sxElement_arctan2' :: SXElementClass a => a -> SX -> IO SX
sxElement_arctan2' x = casADi__SXElement__arctan2' (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXElement__getTemp" c_CasADi__SXElement__getTemp
  :: Ptr SXElement' -> IO CInt
casADi__SXElement__getTemp
  :: SXElement -> IO Int
casADi__SXElement__getTemp x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SXElement__getTemp x0' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL] 
-}
sxElement_getTemp :: SXElementClass a => a -> IO Int
sxElement_getTemp x = casADi__SXElement__getTemp (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXElement__setTemp" c_CasADi__SXElement__setTemp
  :: Ptr SXElement' -> CInt -> IO ()
casADi__SXElement__setTemp
  :: SXElement -> Int -> IO ()
casADi__SXElement__setTemp x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__SXElement__setTemp x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL] 
-}
sxElement_setTemp :: SXElementClass a => a -> Int -> IO ()
sxElement_setTemp x = casADi__SXElement__setTemp (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXElement__marked" c_CasADi__SXElement__marked
  :: Ptr SXElement' -> IO CInt
casADi__SXElement__marked
  :: SXElement -> IO Bool
casADi__SXElement__marked x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SXElement__marked x0' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL] 
-}
sxElement_marked :: SXElementClass a => a -> IO Bool
sxElement_marked x = casADi__SXElement__marked (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXElement__mark" c_CasADi__SXElement__mark
  :: Ptr SXElement' -> IO ()
casADi__SXElement__mark
  :: SXElement -> IO ()
casADi__SXElement__mark x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SXElement__mark x0' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL] 
-}
sxElement_mark :: SXElementClass a => a -> IO ()
sxElement_mark x = casADi__SXElement__mark (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXElement__assignIfDuplicate" c_CasADi__SXElement__assignIfDuplicate
  :: Ptr SXElement' -> Ptr SXElement' -> CInt -> IO ()
casADi__SXElement__assignIfDuplicate
  :: SXElement -> SXElement -> Int -> IO ()
casADi__SXElement__assignIfDuplicate x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__SXElement__assignIfDuplicate x0' x1' x2' >>= wrapReturn

-- classy wrapper
{-|
>[INTERNAL]
>Assign to another expression, if a duplicate. Check for equality up to a
>given depth.
-}
sxElement_assignIfDuplicate :: SXElementClass a => a -> SXElement -> Int -> IO ()
sxElement_assignIfDuplicate x = casADi__SXElement__assignIfDuplicate (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXElement__assignIfDuplicate_TIC" c_CasADi__SXElement__assignIfDuplicate_TIC
  :: Ptr SXElement' -> Ptr SXElement' -> IO ()
casADi__SXElement__assignIfDuplicate'
  :: SXElement -> SXElement -> IO ()
casADi__SXElement__assignIfDuplicate' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__SXElement__assignIfDuplicate_TIC x0' x1' >>= wrapReturn

-- classy wrapper
sxElement_assignIfDuplicate' :: SXElementClass a => a -> SXElement -> IO ()
sxElement_assignIfDuplicate' x = casADi__SXElement__assignIfDuplicate' (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXElement__isNull" c_CasADi__SXElement__isNull
  :: Ptr SXElement' -> IO CInt
casADi__SXElement__isNull
  :: SXElement -> IO Bool
casADi__SXElement__isNull x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SXElement__isNull x0' >>= wrapReturn

-- classy wrapper
{-|
>SXElement nodes are not allowed to be null.
-}
sxElement_isNull :: SXElementClass a => a -> IO Bool
sxElement_isNull x = casADi__SXElement__isNull (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SXElement__SXElement" c_CasADi__SXElement__SXElement
  :: IO (Ptr SXElement')
casADi__SXElement__SXElement
  :: IO SXElement
casADi__SXElement__SXElement  =
  c_CasADi__SXElement__SXElement  >>= wrapReturn

-- classy wrapper
{-|
>>  CasADi::SXElement::SXElement()
>------------------------------------------------------------------------
>
>Default constructor (not-a-number) Object is initialised as not-a-number.
>
>>  CasADi::SXElement::SXElement(double val)
>------------------------------------------------------------------------
>
>Numerical constant constructor.
>
>Parameters:
>-----------
>
>val:  Numerical value
>
>>  CasADi::SXElement::SXElement(const std::string &name)
>------------------------------------------------------------------------
>
>[DEPRECATED] Replaced with SXElement::sym
>
>>  CasADi::SXElement::SXElement(SXNode *node, bool dummy)
>------------------------------------------------------------------------
>[INTERNAL] 
>Create an expression from a node: extra dummy argument to avoid
>ambigousity for 0/NULL
>
>>  CasADi::SXElement::SXElement(const SXElement &scalar)
>------------------------------------------------------------------------
>[INTERNAL] 
>Copy constructor.
-}
sxElement :: IO SXElement
sxElement = casADi__SXElement__SXElement


-- direct wrapper
foreign import ccall unsafe "CasADi__SXElement__SXElement_TIC" c_CasADi__SXElement__SXElement_TIC
  :: CDouble -> IO (Ptr SXElement')
casADi__SXElement__SXElement'
  :: Double -> IO SXElement
casADi__SXElement__SXElement' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SXElement__SXElement_TIC x0' >>= wrapReturn

-- classy wrapper
sxElement' :: Double -> IO SXElement
sxElement' = casADi__SXElement__SXElement'