casadi-bindings-core-2.1.3.0: Casadi/Core/Classes/SXElement.hs

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

module Casadi.Core.Classes.SXElement
       (
         SXElement,
         SXElementClass(..),
         sxElement__0,
         sxElement__1,
         sxElement___add__,
         sxElement___constpow__,
         sxElement___copysign____0,
         sxElement___copysign____1,
         sxElement___div__,
         sxElement___eq__,
         sxElement___ge__,
         sxElement___gt__,
         sxElement___hash__,
         sxElement___le__,
         sxElement___lt__,
         sxElement___mldivide__,
         sxElement___mpower__,
         sxElement___mrdivide__,
         sxElement___mul__,
         sxElement___ne__,
         sxElement___nonzero__,
         sxElement___pow__,
         sxElement___radd__,
         sxElement___rdiv__,
         sxElement___req__,
         sxElement___rge__,
         sxElement___rgt__,
         sxElement___rle__,
         sxElement___rlt__,
         sxElement___rmul__,
         sxElement___rne__,
         sxElement___rsub__,
         sxElement___rtruediv__,
         sxElement___sub__,
         sxElement___truediv____0,
         sxElement___truediv____1,
         sxElement_arccos,
         sxElement_arccosh,
         sxElement_arcsin,
         sxElement_arcsinh,
         sxElement_arctan,
         sxElement_arctan2__0,
         sxElement_arctan2__1,
         sxElement_arctanh,
         sxElement_assignIfDuplicate__0,
         sxElement_assignIfDuplicate__1,
         sxElement_binary,
         sxElement_ceil,
         sxElement_constpow__0,
         sxElement_constpow__1,
         sxElement_cos,
         sxElement_cosh,
         sxElement_erf,
         sxElement_erfinv,
         sxElement_exp,
         sxElement_fabs,
         sxElement_floor,
         sxElement_fmax__0,
         sxElement_fmax__1,
         sxElement_fmin__0,
         sxElement_fmin__1,
         sxElement_fmod,
         sxElement_getDep__0,
         sxElement_getDep__1,
         sxElement_getDescription,
         sxElement_getIntValue,
         sxElement_getName,
         sxElement_getNdeps,
         sxElement_getOp,
         sxElement_getRepresentation,
         sxElement_getTemp,
         sxElement_getValue,
         sxElement_hasDep,
         sxElement_if_else_zero,
         sxElement_inv,
         sxElement_isAlmostZero,
         sxElement_isCommutative,
         sxElement_isConstant,
         sxElement_isDoubled,
         sxElement_isEqual__0,
         sxElement_isEqual__1,
         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_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.Marshal ( new, free )
import Foreign.Storable ( peek )
import Foreign.Ptr ( Ptr, nullPtr )
import Foreign.ForeignPtr ( newForeignPtr )
import System.IO.Unsafe ( unsafePerformIO ) -- for show instances

import Casadi.Internal.CToolsInstances ( )
import Casadi.Internal.FormatException ( formatException )
import Casadi.Internal.MarshalTypes ( StdVec, StdString) -- StdPair StdOstream'
import Casadi.Internal.Marshal ( Marshal(..), withMarshal )
import Casadi.Internal.WrapReturn ( WrapReturn(..) )
import Casadi.Core.Data
import Casadi.Core.Enums

-- direct wrapper
foreign import ccall unsafe "casadi__SXElement__CONSTRUCTOR__0" c_casadi__SXElement__CONSTRUCTOR__0
  :: Ptr (Ptr StdString) -> CDouble -> IO (Ptr SXElement')
casadi__SXElement__CONSTRUCTOR__0
  :: Double -> IO SXElement
casadi__SXElement__CONSTRUCTOR__0 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement__CONSTRUCTOR__0 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sxElement__0 :: Double -> IO SXElement
sxElement__0 = casadi__SXElement__CONSTRUCTOR__0


-- direct wrapper
foreign import ccall unsafe "casadi__SXElement__CONSTRUCTOR__1" c_casadi__SXElement__CONSTRUCTOR__1
  :: Ptr (Ptr StdString) -> IO (Ptr SXElement')
casadi__SXElement__CONSTRUCTOR__1
  :: IO SXElement
casadi__SXElement__CONSTRUCTOR__1  =

  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement__CONSTRUCTOR__1 errStrPtrP 
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sxElement__1 :: IO SXElement
sxElement__1 = casadi__SXElement__CONSTRUCTOR__1


-- direct wrapper
foreign import ccall unsafe "casadi__SXElement____add__" c_casadi__SXElement____add__
  :: Ptr (Ptr StdString) -> 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' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement____add__ errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- 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____constpow__" c_casadi__SXElement____constpow__
  :: Ptr (Ptr StdString) -> 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' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement____constpow__ errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- 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____copysign____0" c_casadi__SXElement____copysign____0
  :: Ptr (Ptr StdString) -> Ptr SXElement' -> Ptr SX' -> IO (Ptr SX')
casadi__SXElement____copysign____0
  :: SXElement -> SX -> IO SX
casadi__SXElement____copysign____0 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement____copysign____0 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sxElement___copysign____0 :: SXElementClass a => a -> SX -> IO SX
sxElement___copysign____0 x = casadi__SXElement____copysign____0 (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "casadi__SXElement____copysign____1" c_casadi__SXElement____copysign____1
  :: Ptr (Ptr StdString) -> Ptr SXElement' -> Ptr SXElement' -> IO (Ptr SXElement')
casadi__SXElement____copysign____1
  :: SXElement -> SXElement -> IO SXElement
casadi__SXElement____copysign____1 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement____copysign____1 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sxElement___copysign____1 :: SXElementClass a => a -> SXElement -> IO SXElement
sxElement___copysign____1 x = casadi__SXElement____copysign____1 (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "casadi__SXElement____div__" c_casadi__SXElement____div__
  :: Ptr (Ptr StdString) -> 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' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement____div__ errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- 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____eq__" c_casadi__SXElement____eq__
  :: Ptr (Ptr StdString) -> 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' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement____eq__ errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- 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____ge__" c_casadi__SXElement____ge__
  :: Ptr (Ptr StdString) -> Ptr SXElement' -> Ptr SXElement' -> IO (Ptr SXElement')
casadi__SXElement____ge__
  :: SXElement -> SXElement -> IO SXElement
casadi__SXElement____ge__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement____ge__ errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sxElement___ge__ :: SXElementClass a => a -> SXElement -> IO SXElement
sxElement___ge__ x = casadi__SXElement____ge__ (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "casadi__SXElement____gt__" c_casadi__SXElement____gt__
  :: Ptr (Ptr StdString) -> Ptr SXElement' -> Ptr SXElement' -> IO (Ptr SXElement')
casadi__SXElement____gt__
  :: SXElement -> SXElement -> IO SXElement
casadi__SXElement____gt__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement____gt__ errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sxElement___gt__ :: SXElementClass a => a -> SXElement -> IO SXElement
sxElement___gt__ x = casadi__SXElement____gt__ (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "casadi__SXElement____hash__" c_casadi__SXElement____hash__
  :: Ptr (Ptr StdString) -> Ptr SXElement' -> IO CLong
casadi__SXElement____hash__
  :: SXElement -> IO Int
casadi__SXElement____hash__ x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement____hash__ errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sxElement___hash__ :: SXElementClass a => a -> IO Int
sxElement___hash__ x = casadi__SXElement____hash__ (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "casadi__SXElement____le__" c_casadi__SXElement____le__
  :: Ptr (Ptr StdString) -> 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' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement____le__ errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- 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____lt__" c_casadi__SXElement____lt__
  :: Ptr (Ptr StdString) -> 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' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement____lt__ errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- 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____mldivide__" c_casadi__SXElement____mldivide__
  :: Ptr (Ptr StdString) -> Ptr SXElement' -> Ptr SXElement' -> IO (Ptr SXElement')
casadi__SXElement____mldivide__
  :: SXElement -> SXElement -> IO SXElement
casadi__SXElement____mldivide__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement____mldivide__ errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sxElement___mldivide__ :: SXElementClass a => a -> SXElement -> IO SXElement
sxElement___mldivide__ x = casadi__SXElement____mldivide__ (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "casadi__SXElement____mpower__" c_casadi__SXElement____mpower__
  :: Ptr (Ptr StdString) -> 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' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement____mpower__ errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- 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____mrdivide__" c_casadi__SXElement____mrdivide__
  :: Ptr (Ptr StdString) -> 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' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement____mrdivide__ errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- 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____mul__" c_casadi__SXElement____mul__
  :: Ptr (Ptr StdString) -> 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' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement____mul__ errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- 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____ne__" c_casadi__SXElement____ne__
  :: Ptr (Ptr StdString) -> 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' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement____ne__ errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- 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____nonzero__" c_casadi__SXElement____nonzero__
  :: Ptr (Ptr StdString) -> Ptr SXElement' -> IO CInt
casadi__SXElement____nonzero__
  :: SXElement -> IO Bool
casadi__SXElement____nonzero__ x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement____nonzero__ errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sxElement___nonzero__ :: SXElementClass a => a -> IO Bool
sxElement___nonzero__ x = casadi__SXElement____nonzero__ (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "casadi__SXElement____pow__" c_casadi__SXElement____pow__
  :: Ptr (Ptr StdString) -> 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' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement____pow__ errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- 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____radd__" c_casadi__SXElement____radd__
  :: Ptr (Ptr StdString) -> Ptr SXElement' -> Ptr SXElement' -> IO (Ptr SXElement')
casadi__SXElement____radd__
  :: SXElement -> SXElement -> IO SXElement
casadi__SXElement____radd__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement____radd__ errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sxElement___radd__ :: SXElementClass a => a -> SXElement -> IO SXElement
sxElement___radd__ x = casadi__SXElement____radd__ (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "casadi__SXElement____rdiv__" c_casadi__SXElement____rdiv__
  :: Ptr (Ptr StdString) -> Ptr SXElement' -> Ptr SXElement' -> IO (Ptr SXElement')
casadi__SXElement____rdiv__
  :: SXElement -> SXElement -> IO SXElement
casadi__SXElement____rdiv__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement____rdiv__ errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sxElement___rdiv__ :: SXElementClass a => a -> SXElement -> IO SXElement
sxElement___rdiv__ x = casadi__SXElement____rdiv__ (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "casadi__SXElement____req__" c_casadi__SXElement____req__
  :: Ptr (Ptr StdString) -> Ptr SXElement' -> Ptr SXElement' -> IO (Ptr SXElement')
casadi__SXElement____req__
  :: SXElement -> SXElement -> IO SXElement
casadi__SXElement____req__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement____req__ errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sxElement___req__ :: SXElementClass a => a -> SXElement -> IO SXElement
sxElement___req__ x = casadi__SXElement____req__ (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "casadi__SXElement____rge__" c_casadi__SXElement____rge__
  :: Ptr (Ptr StdString) -> Ptr SXElement' -> Ptr SXElement' -> IO (Ptr SXElement')
casadi__SXElement____rge__
  :: SXElement -> SXElement -> IO SXElement
casadi__SXElement____rge__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement____rge__ errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sxElement___rge__ :: SXElementClass a => a -> SXElement -> IO SXElement
sxElement___rge__ x = casadi__SXElement____rge__ (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "casadi__SXElement____rgt__" c_casadi__SXElement____rgt__
  :: Ptr (Ptr StdString) -> Ptr SXElement' -> Ptr SXElement' -> IO (Ptr SXElement')
casadi__SXElement____rgt__
  :: SXElement -> SXElement -> IO SXElement
casadi__SXElement____rgt__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement____rgt__ errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sxElement___rgt__ :: SXElementClass a => a -> SXElement -> IO SXElement
sxElement___rgt__ x = casadi__SXElement____rgt__ (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "casadi__SXElement____rle__" c_casadi__SXElement____rle__
  :: Ptr (Ptr StdString) -> Ptr SXElement' -> Ptr SXElement' -> IO (Ptr SXElement')
casadi__SXElement____rle__
  :: SXElement -> SXElement -> IO SXElement
casadi__SXElement____rle__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement____rle__ errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sxElement___rle__ :: SXElementClass a => a -> SXElement -> IO SXElement
sxElement___rle__ x = casadi__SXElement____rle__ (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "casadi__SXElement____rlt__" c_casadi__SXElement____rlt__
  :: Ptr (Ptr StdString) -> Ptr SXElement' -> Ptr SXElement' -> IO (Ptr SXElement')
casadi__SXElement____rlt__
  :: SXElement -> SXElement -> IO SXElement
casadi__SXElement____rlt__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement____rlt__ errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sxElement___rlt__ :: SXElementClass a => a -> SXElement -> IO SXElement
sxElement___rlt__ x = casadi__SXElement____rlt__ (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "casadi__SXElement____rmul__" c_casadi__SXElement____rmul__
  :: Ptr (Ptr StdString) -> Ptr SXElement' -> Ptr SXElement' -> IO (Ptr SXElement')
casadi__SXElement____rmul__
  :: SXElement -> SXElement -> IO SXElement
casadi__SXElement____rmul__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement____rmul__ errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sxElement___rmul__ :: SXElementClass a => a -> SXElement -> IO SXElement
sxElement___rmul__ x = casadi__SXElement____rmul__ (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "casadi__SXElement____rne__" c_casadi__SXElement____rne__
  :: Ptr (Ptr StdString) -> Ptr SXElement' -> Ptr SXElement' -> IO (Ptr SXElement')
casadi__SXElement____rne__
  :: SXElement -> SXElement -> IO SXElement
casadi__SXElement____rne__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement____rne__ errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sxElement___rne__ :: SXElementClass a => a -> SXElement -> IO SXElement
sxElement___rne__ x = casadi__SXElement____rne__ (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "casadi__SXElement____rsub__" c_casadi__SXElement____rsub__
  :: Ptr (Ptr StdString) -> Ptr SXElement' -> Ptr SXElement' -> IO (Ptr SXElement')
casadi__SXElement____rsub__
  :: SXElement -> SXElement -> IO SXElement
casadi__SXElement____rsub__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement____rsub__ errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sxElement___rsub__ :: SXElementClass a => a -> SXElement -> IO SXElement
sxElement___rsub__ x = casadi__SXElement____rsub__ (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "casadi__SXElement____rtruediv__" c_casadi__SXElement____rtruediv__
  :: Ptr (Ptr StdString) -> Ptr SXElement' -> Ptr SXElement' -> IO (Ptr SXElement')
casadi__SXElement____rtruediv__
  :: SXElement -> SXElement -> IO SXElement
casadi__SXElement____rtruediv__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement____rtruediv__ errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sxElement___rtruediv__ :: SXElementClass a => a -> SXElement -> IO SXElement
sxElement___rtruediv__ x = casadi__SXElement____rtruediv__ (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "casadi__SXElement____sub__" c_casadi__SXElement____sub__
  :: Ptr (Ptr StdString) -> 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' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement____sub__ errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- 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____truediv____0" c_casadi__SXElement____truediv____0
  :: Ptr (Ptr StdString) -> Ptr SXElement' -> Ptr SXElement' -> IO (Ptr SXElement')
casadi__SXElement____truediv____0
  :: SXElement -> SXElement -> IO SXElement
casadi__SXElement____truediv____0 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement____truediv____0 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sxElement___truediv____0 :: SXElementClass a => a -> SXElement -> IO SXElement
sxElement___truediv____0 x = casadi__SXElement____truediv____0 (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "casadi__SXElement____truediv____1" c_casadi__SXElement____truediv____1
  :: Ptr (Ptr StdString) -> Ptr SXElement' -> Ptr SXElement' -> IO (Ptr SXElement')
casadi__SXElement____truediv____1
  :: SXElement -> SXElement -> IO SXElement
casadi__SXElement____truediv____1 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement____truediv____1 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sxElement___truediv____1 :: SXElementClass a => a -> SXElement -> IO SXElement
sxElement___truediv____1 x = casadi__SXElement____truediv____1 (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "casadi__SXElement__arccos" c_casadi__SXElement__arccos
  :: Ptr (Ptr StdString) -> Ptr SXElement' -> IO (Ptr SXElement')
casadi__SXElement__arccos
  :: SXElement -> IO SXElement
casadi__SXElement__arccos x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement__arccos errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- 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__arccosh" c_casadi__SXElement__arccosh
  :: Ptr (Ptr StdString) -> Ptr SXElement' -> IO (Ptr SXElement')
casadi__SXElement__arccosh
  :: SXElement -> IO SXElement
casadi__SXElement__arccosh x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement__arccosh errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- 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__arcsin" c_casadi__SXElement__arcsin
  :: Ptr (Ptr StdString) -> Ptr SXElement' -> IO (Ptr SXElement')
casadi__SXElement__arcsin
  :: SXElement -> IO SXElement
casadi__SXElement__arcsin x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement__arcsin errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- 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__arcsinh" c_casadi__SXElement__arcsinh
  :: Ptr (Ptr StdString) -> Ptr SXElement' -> IO (Ptr SXElement')
casadi__SXElement__arcsinh
  :: SXElement -> IO SXElement
casadi__SXElement__arcsinh x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement__arcsinh errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- 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__arctan" c_casadi__SXElement__arctan
  :: Ptr (Ptr StdString) -> Ptr SXElement' -> IO (Ptr SXElement')
casadi__SXElement__arctan
  :: SXElement -> IO SXElement
casadi__SXElement__arctan x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement__arctan errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- 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__arctan2__0" c_casadi__SXElement__arctan2__0
  :: Ptr (Ptr StdString) -> Ptr SXElement' -> Ptr SX' -> IO (Ptr SX')
casadi__SXElement__arctan2__0
  :: SXElement -> SX -> IO SX
casadi__SXElement__arctan2__0 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement__arctan2__0 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sxElement_arctan2__0 :: SXElementClass a => a -> SX -> IO SX
sxElement_arctan2__0 x = casadi__SXElement__arctan2__0 (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "casadi__SXElement__arctan2__1" c_casadi__SXElement__arctan2__1
  :: Ptr (Ptr StdString) -> Ptr SXElement' -> Ptr SXElement' -> IO (Ptr SXElement')
casadi__SXElement__arctan2__1
  :: SXElement -> SXElement -> IO SXElement
casadi__SXElement__arctan2__1 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement__arctan2__1 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sxElement_arctan2__1 :: SXElementClass a => a -> SXElement -> IO SXElement
sxElement_arctan2__1 x = casadi__SXElement__arctan2__1 (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "casadi__SXElement__arctanh" c_casadi__SXElement__arctanh
  :: Ptr (Ptr StdString) -> Ptr SXElement' -> IO (Ptr SXElement')
casadi__SXElement__arctanh
  :: SXElement -> IO SXElement
casadi__SXElement__arctanh x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement__arctanh errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- 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__assignIfDuplicate__0" c_casadi__SXElement__assignIfDuplicate__0
  :: Ptr (Ptr StdString) -> Ptr SXElement' -> Ptr SXElement' -> IO ()
casadi__SXElement__assignIfDuplicate__0
  :: SXElement -> SXElement -> IO ()
casadi__SXElement__assignIfDuplicate__0 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement__assignIfDuplicate__0 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sxElement_assignIfDuplicate__0 :: SXElementClass a => a -> SXElement -> IO ()
sxElement_assignIfDuplicate__0 x = casadi__SXElement__assignIfDuplicate__0 (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "casadi__SXElement__assignIfDuplicate__1" c_casadi__SXElement__assignIfDuplicate__1
  :: Ptr (Ptr StdString) -> Ptr SXElement' -> Ptr SXElement' -> CInt -> IO ()
casadi__SXElement__assignIfDuplicate__1
  :: SXElement -> SXElement -> Int -> IO ()
casadi__SXElement__assignIfDuplicate__1 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement__assignIfDuplicate__1 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sxElement_assignIfDuplicate__1 :: SXElementClass a => a -> SXElement -> Int -> IO ()
sxElement_assignIfDuplicate__1 x = casadi__SXElement__assignIfDuplicate__1 (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "casadi__SXElement__binary" c_casadi__SXElement__binary
  :: Ptr (Ptr StdString) -> 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' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement__binary errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


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


-- direct wrapper
foreign import ccall unsafe "casadi__SXElement__ceil" c_casadi__SXElement__ceil
  :: Ptr (Ptr StdString) -> Ptr SXElement' -> IO (Ptr SXElement')
casadi__SXElement__ceil
  :: SXElement -> IO SXElement
casadi__SXElement__ceil x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement__ceil errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- 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__constpow__0" c_casadi__SXElement__constpow__0
  :: Ptr (Ptr StdString) -> Ptr SXElement' -> Ptr SX' -> IO (Ptr SX')
casadi__SXElement__constpow__0
  :: SXElement -> SX -> IO SX
casadi__SXElement__constpow__0 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement__constpow__0 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sxElement_constpow__0 :: SXElementClass a => a -> SX -> IO SX
sxElement_constpow__0 x = casadi__SXElement__constpow__0 (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "casadi__SXElement__constpow__1" c_casadi__SXElement__constpow__1
  :: Ptr (Ptr StdString) -> Ptr SXElement' -> Ptr SXElement' -> IO (Ptr SXElement')
casadi__SXElement__constpow__1
  :: SXElement -> SXElement -> IO SXElement
casadi__SXElement__constpow__1 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement__constpow__1 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sxElement_constpow__1 :: SXElementClass a => a -> SXElement -> IO SXElement
sxElement_constpow__1 x = casadi__SXElement__constpow__1 (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "casadi__SXElement__cos" c_casadi__SXElement__cos
  :: Ptr (Ptr StdString) -> Ptr SXElement' -> IO (Ptr SXElement')
casadi__SXElement__cos
  :: SXElement -> IO SXElement
casadi__SXElement__cos x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement__cos errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- 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__cosh" c_casadi__SXElement__cosh
  :: Ptr (Ptr StdString) -> Ptr SXElement' -> IO (Ptr SXElement')
casadi__SXElement__cosh
  :: SXElement -> IO SXElement
casadi__SXElement__cosh x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement__cosh errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- 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__erf" c_casadi__SXElement__erf
  :: Ptr (Ptr StdString) -> Ptr SXElement' -> IO (Ptr SXElement')
casadi__SXElement__erf
  :: SXElement -> IO SXElement
casadi__SXElement__erf x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement__erf errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- 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 (Ptr StdString) -> Ptr SXElement' -> IO (Ptr SXElement')
casadi__SXElement__erfinv
  :: SXElement -> IO SXElement
casadi__SXElement__erfinv x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement__erfinv errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- 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__exp" c_casadi__SXElement__exp
  :: Ptr (Ptr StdString) -> Ptr SXElement' -> IO (Ptr SXElement')
casadi__SXElement__exp
  :: SXElement -> IO SXElement
casadi__SXElement__exp x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement__exp errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- 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__fabs" c_casadi__SXElement__fabs
  :: Ptr (Ptr StdString) -> Ptr SXElement' -> IO (Ptr SXElement')
casadi__SXElement__fabs
  :: SXElement -> IO SXElement
casadi__SXElement__fabs x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement__fabs errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- 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__floor" c_casadi__SXElement__floor
  :: Ptr (Ptr StdString) -> Ptr SXElement' -> IO (Ptr SXElement')
casadi__SXElement__floor
  :: SXElement -> IO SXElement
casadi__SXElement__floor x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement__floor errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- 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__fmax__0" c_casadi__SXElement__fmax__0
  :: Ptr (Ptr StdString) -> Ptr SXElement' -> Ptr SX' -> IO (Ptr SX')
casadi__SXElement__fmax__0
  :: SXElement -> SX -> IO SX
casadi__SXElement__fmax__0 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement__fmax__0 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sxElement_fmax__0 :: SXElementClass a => a -> SX -> IO SX
sxElement_fmax__0 x = casadi__SXElement__fmax__0 (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "casadi__SXElement__fmax__1" c_casadi__SXElement__fmax__1
  :: Ptr (Ptr StdString) -> Ptr SXElement' -> Ptr SXElement' -> IO (Ptr SXElement')
casadi__SXElement__fmax__1
  :: SXElement -> SXElement -> IO SXElement
casadi__SXElement__fmax__1 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement__fmax__1 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sxElement_fmax__1 :: SXElementClass a => a -> SXElement -> IO SXElement
sxElement_fmax__1 x = casadi__SXElement__fmax__1 (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "casadi__SXElement__fmin__0" c_casadi__SXElement__fmin__0
  :: Ptr (Ptr StdString) -> Ptr SXElement' -> Ptr SX' -> IO (Ptr SX')
casadi__SXElement__fmin__0
  :: SXElement -> SX -> IO SX
casadi__SXElement__fmin__0 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement__fmin__0 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sxElement_fmin__0 :: SXElementClass a => a -> SX -> IO SX
sxElement_fmin__0 x = casadi__SXElement__fmin__0 (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "casadi__SXElement__fmin__1" c_casadi__SXElement__fmin__1
  :: Ptr (Ptr StdString) -> Ptr SXElement' -> Ptr SXElement' -> IO (Ptr SXElement')
casadi__SXElement__fmin__1
  :: SXElement -> SXElement -> IO SXElement
casadi__SXElement__fmin__1 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement__fmin__1 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sxElement_fmin__1 :: SXElementClass a => a -> SXElement -> IO SXElement
sxElement_fmin__1 x = casadi__SXElement__fmin__1 (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "casadi__SXElement__fmod" c_casadi__SXElement__fmod
  :: Ptr (Ptr StdString) -> Ptr SXElement' -> Ptr SXElement' -> IO (Ptr SXElement')
casadi__SXElement__fmod
  :: SXElement -> SXElement -> IO SXElement
casadi__SXElement__fmod x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement__fmod errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sxElement_fmod :: SXElementClass a => a -> SXElement -> IO SXElement
sxElement_fmod x = casadi__SXElement__fmod (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "casadi__SXElement__getDep__0" c_casadi__SXElement__getDep__0
  :: Ptr (Ptr StdString) -> Ptr SXElement' -> IO (Ptr SXElement')
casadi__SXElement__getDep__0
  :: SXElement -> IO SXElement
casadi__SXElement__getDep__0 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement__getDep__0 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sxElement_getDep__0 :: SXElementClass a => a -> IO SXElement
sxElement_getDep__0 x = casadi__SXElement__getDep__0 (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "casadi__SXElement__getDep__1" c_casadi__SXElement__getDep__1
  :: Ptr (Ptr StdString) -> Ptr SXElement' -> CInt -> IO (Ptr SXElement')
casadi__SXElement__getDep__1
  :: SXElement -> Int -> IO SXElement
casadi__SXElement__getDep__1 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement__getDep__1 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sxElement_getDep__1 :: SXElementClass a => a -> Int -> IO SXElement
sxElement_getDep__1 x = casadi__SXElement__getDep__1 (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "casadi__SXElement__getIntValue" c_casadi__SXElement__getIntValue
  :: Ptr (Ptr StdString) -> Ptr SXElement' -> IO CInt
casadi__SXElement__getIntValue
  :: SXElement -> IO Int
casadi__SXElement__getIntValue x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement__getIntValue errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- 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__getName" c_casadi__SXElement__getName
  :: Ptr (Ptr StdString) -> Ptr SXElement' -> IO (Ptr StdString)
casadi__SXElement__getName
  :: SXElement -> IO String
casadi__SXElement__getName x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement__getName errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sxElement_getName :: SXElementClass a => a -> IO String
sxElement_getName x = casadi__SXElement__getName (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "casadi__SXElement__getNdeps" c_casadi__SXElement__getNdeps
  :: Ptr (Ptr StdString) -> Ptr SXElement' -> IO CInt
casadi__SXElement__getNdeps
  :: SXElement -> IO Int
casadi__SXElement__getNdeps x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement__getNdeps errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sxElement_getNdeps :: SXElementClass a => a -> IO Int
sxElement_getNdeps x = casadi__SXElement__getNdeps (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "casadi__SXElement__getOp" c_casadi__SXElement__getOp
  :: Ptr (Ptr StdString) -> Ptr SXElement' -> IO CInt
casadi__SXElement__getOp
  :: SXElement -> IO Int
casadi__SXElement__getOp x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement__getOp errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- 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__getTemp" c_casadi__SXElement__getTemp
  :: Ptr (Ptr StdString) -> Ptr SXElement' -> IO CInt
casadi__SXElement__getTemp
  :: SXElement -> IO Int
casadi__SXElement__getTemp x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement__getTemp errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sxElement_getTemp :: SXElementClass a => a -> IO Int
sxElement_getTemp x = casadi__SXElement__getTemp (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "casadi__SXElement__getValue" c_casadi__SXElement__getValue
  :: Ptr (Ptr StdString) -> Ptr SXElement' -> IO CDouble
casadi__SXElement__getValue
  :: SXElement -> IO Double
casadi__SXElement__getValue x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement__getValue errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- 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__hasDep" c_casadi__SXElement__hasDep
  :: Ptr (Ptr StdString) -> Ptr SXElement' -> IO CInt
casadi__SXElement__hasDep
  :: SXElement -> IO Bool
casadi__SXElement__hasDep x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement__hasDep errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- 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__if_else_zero" c_casadi__SXElement__if_else_zero
  :: Ptr (Ptr StdString) -> 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' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement__if_else_zero errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- 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__inv" c_casadi__SXElement__inv
  :: Ptr (Ptr StdString) -> Ptr SXElement' -> IO (Ptr SXElement')
casadi__SXElement__inv
  :: SXElement -> IO SXElement
casadi__SXElement__inv x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement__inv errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- 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__isAlmostZero" c_casadi__SXElement__isAlmostZero
  :: Ptr (Ptr StdString) -> Ptr SXElement' -> CDouble -> IO CInt
casadi__SXElement__isAlmostZero
  :: SXElement -> Double -> IO Bool
casadi__SXElement__isAlmostZero x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement__isAlmostZero errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- 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__isCommutative" c_casadi__SXElement__isCommutative
  :: Ptr (Ptr StdString) -> Ptr SXElement' -> IO CInt
casadi__SXElement__isCommutative
  :: SXElement -> IO Bool
casadi__SXElement__isCommutative x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement__isCommutative errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sxElement_isCommutative :: SXElementClass a => a -> IO Bool
sxElement_isCommutative x = casadi__SXElement__isCommutative (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "casadi__SXElement__isConstant" c_casadi__SXElement__isConstant
  :: Ptr (Ptr StdString) -> Ptr SXElement' -> IO CInt
casadi__SXElement__isConstant
  :: SXElement -> IO Bool
casadi__SXElement__isConstant x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement__isConstant errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- 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__isDoubled" c_casadi__SXElement__isDoubled
  :: Ptr (Ptr StdString) -> Ptr SXElement' -> IO CInt
casadi__SXElement__isDoubled
  :: SXElement -> IO Bool
casadi__SXElement__isDoubled x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement__isDoubled errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sxElement_isDoubled :: SXElementClass a => a -> IO Bool
sxElement_isDoubled x = casadi__SXElement__isDoubled (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "casadi__SXElement__isEqual__0" c_casadi__SXElement__isEqual__0
  :: Ptr (Ptr StdString) -> Ptr SXElement' -> Ptr SXElement' -> IO CInt
casadi__SXElement__isEqual__0
  :: SXElement -> SXElement -> IO Bool
casadi__SXElement__isEqual__0 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement__isEqual__0 errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sxElement_isEqual__0 :: SXElementClass a => a -> SXElement -> IO Bool
sxElement_isEqual__0 x = casadi__SXElement__isEqual__0 (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "casadi__SXElement__isEqual__1" c_casadi__SXElement__isEqual__1
  :: Ptr (Ptr StdString) -> Ptr SXElement' -> Ptr SXElement' -> CInt -> IO CInt
casadi__SXElement__isEqual__1
  :: SXElement -> SXElement -> Int -> IO Bool
casadi__SXElement__isEqual__1 x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement__isEqual__1 errStrPtrP x0' x1' x2'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sxElement_isEqual__1 :: SXElementClass a => a -> SXElement -> Int -> IO Bool
sxElement_isEqual__1 x = casadi__SXElement__isEqual__1 (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "casadi__SXElement__isInf" c_casadi__SXElement__isInf
  :: Ptr (Ptr StdString) -> Ptr SXElement' -> IO CInt
casadi__SXElement__isInf
  :: SXElement -> IO Bool
casadi__SXElement__isInf x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement__isInf errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- 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__isInteger" c_casadi__SXElement__isInteger
  :: Ptr (Ptr StdString) -> Ptr SXElement' -> IO CInt
casadi__SXElement__isInteger
  :: SXElement -> IO Bool
casadi__SXElement__isInteger x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement__isInteger errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- 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__isLeaf" c_casadi__SXElement__isLeaf
  :: Ptr (Ptr StdString) -> Ptr SXElement' -> IO CInt
casadi__SXElement__isLeaf
  :: SXElement -> IO Bool
casadi__SXElement__isLeaf x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement__isLeaf errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sxElement_isLeaf :: SXElementClass a => a -> IO Bool
sxElement_isLeaf x = casadi__SXElement__isLeaf (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "casadi__SXElement__isMinusInf" c_casadi__SXElement__isMinusInf
  :: Ptr (Ptr StdString) -> Ptr SXElement' -> IO CInt
casadi__SXElement__isMinusInf
  :: SXElement -> IO Bool
casadi__SXElement__isMinusInf x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement__isMinusInf errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- 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__isMinusOne" c_casadi__SXElement__isMinusOne
  :: Ptr (Ptr StdString) -> Ptr SXElement' -> IO CInt
casadi__SXElement__isMinusOne
  :: SXElement -> IO Bool
casadi__SXElement__isMinusOne x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement__isMinusOne errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- 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 (Ptr StdString) -> Ptr SXElement' -> IO CInt
casadi__SXElement__isNan
  :: SXElement -> IO Bool
casadi__SXElement__isNan x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement__isNan errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- 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__isNonNegative" c_casadi__SXElement__isNonNegative
  :: Ptr (Ptr StdString) -> Ptr SXElement' -> IO CInt
casadi__SXElement__isNonNegative
  :: SXElement -> IO Bool
casadi__SXElement__isNonNegative x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement__isNonNegative errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sxElement_isNonNegative :: SXElementClass a => a -> IO Bool
sxElement_isNonNegative x = casadi__SXElement__isNonNegative (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "casadi__SXElement__isNull" c_casadi__SXElement__isNull
  :: Ptr (Ptr StdString) -> Ptr SXElement' -> IO CInt
casadi__SXElement__isNull
  :: SXElement -> IO Bool
casadi__SXElement__isNull x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement__isNull errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sxElement_isNull :: SXElementClass a => a -> IO Bool
sxElement_isNull x = casadi__SXElement__isNull (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "casadi__SXElement__isOne" c_casadi__SXElement__isOne
  :: Ptr (Ptr StdString) -> Ptr SXElement' -> IO CInt
casadi__SXElement__isOne
  :: SXElement -> IO Bool
casadi__SXElement__isOne x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement__isOne errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- 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__isOp" c_casadi__SXElement__isOp
  :: Ptr (Ptr StdString) -> Ptr SXElement' -> CInt -> IO CInt
casadi__SXElement__isOp
  :: SXElement -> Int -> IO Bool
casadi__SXElement__isOp x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement__isOp errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- 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 (Ptr StdString) -> Ptr SXElement' -> IO CInt
casadi__SXElement__isRegular
  :: SXElement -> IO Bool
casadi__SXElement__isRegular x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement__isRegular errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sxElement_isRegular :: SXElementClass a => a -> IO Bool
sxElement_isRegular x = casadi__SXElement__isRegular (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "casadi__SXElement__isSymbolic" c_casadi__SXElement__isSymbolic
  :: Ptr (Ptr StdString) -> Ptr SXElement' -> IO CInt
casadi__SXElement__isSymbolic
  :: SXElement -> IO Bool
casadi__SXElement__isSymbolic x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement__isSymbolic errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- 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__isZero" c_casadi__SXElement__isZero
  :: Ptr (Ptr StdString) -> Ptr SXElement' -> IO CInt
casadi__SXElement__isZero
  :: SXElement -> IO Bool
casadi__SXElement__isZero x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement__isZero errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- 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__log" c_casadi__SXElement__log
  :: Ptr (Ptr StdString) -> Ptr SXElement' -> IO (Ptr SXElement')
casadi__SXElement__log
  :: SXElement -> IO SXElement
casadi__SXElement__log x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement__log errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- 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__log10" c_casadi__SXElement__log10
  :: Ptr (Ptr StdString) -> Ptr SXElement' -> IO (Ptr SXElement')
casadi__SXElement__log10
  :: SXElement -> IO SXElement
casadi__SXElement__log10 x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement__log10 errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- 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__logic_and" c_casadi__SXElement__logic_and
  :: Ptr (Ptr StdString) -> 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' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement__logic_and errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- 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_not" c_casadi__SXElement__logic_not
  :: Ptr (Ptr StdString) -> Ptr SXElement' -> IO (Ptr SXElement')
casadi__SXElement__logic_not
  :: SXElement -> IO SXElement
casadi__SXElement__logic_not x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement__logic_not errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- 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_or" c_casadi__SXElement__logic_or
  :: Ptr (Ptr StdString) -> 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' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement__logic_or errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- 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__mark" c_casadi__SXElement__mark
  :: Ptr (Ptr StdString) -> Ptr SXElement' -> IO ()
casadi__SXElement__mark
  :: SXElement -> IO ()
casadi__SXElement__mark x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement__mark errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sxElement_mark :: SXElementClass a => a -> IO ()
sxElement_mark x = casadi__SXElement__mark (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "casadi__SXElement__marked" c_casadi__SXElement__marked
  :: Ptr (Ptr StdString) -> Ptr SXElement' -> IO CInt
casadi__SXElement__marked
  :: SXElement -> IO Bool
casadi__SXElement__marked x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement__marked errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sxElement_marked :: SXElementClass a => a -> IO Bool
sxElement_marked x = casadi__SXElement__marked (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "casadi__SXElement__mul" c_casadi__SXElement__mul
  :: Ptr (Ptr StdString) -> 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' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement__mul errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- 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__printme" c_casadi__SXElement__printme
  :: Ptr (Ptr StdString) -> 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' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement__printme errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- 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__setTemp" c_casadi__SXElement__setTemp
  :: Ptr (Ptr StdString) -> Ptr SXElement' -> CInt -> IO ()
casadi__SXElement__setTemp
  :: SXElement -> Int -> IO ()
casadi__SXElement__setTemp x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement__setTemp errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sxElement_setTemp :: SXElementClass a => a -> Int -> IO ()
sxElement_setTemp x = casadi__SXElement__setTemp (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "casadi__SXElement__sign" c_casadi__SXElement__sign
  :: Ptr (Ptr StdString) -> Ptr SXElement' -> IO (Ptr SXElement')
casadi__SXElement__sign
  :: SXElement -> IO SXElement
casadi__SXElement__sign x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement__sign errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- 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__sin" c_casadi__SXElement__sin
  :: Ptr (Ptr StdString) -> Ptr SXElement' -> IO (Ptr SXElement')
casadi__SXElement__sin
  :: SXElement -> IO SXElement
casadi__SXElement__sin x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement__sin errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- 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__sinh" c_casadi__SXElement__sinh
  :: Ptr (Ptr StdString) -> Ptr SXElement' -> IO (Ptr SXElement')
casadi__SXElement__sinh
  :: SXElement -> IO SXElement
casadi__SXElement__sinh x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement__sinh errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- 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__sq" c_casadi__SXElement__sq
  :: Ptr (Ptr StdString) -> Ptr SXElement' -> IO (Ptr SXElement')
casadi__SXElement__sq
  :: SXElement -> IO SXElement
casadi__SXElement__sq x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement__sq errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- 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__sqrt" c_casadi__SXElement__sqrt
  :: Ptr (Ptr StdString) -> Ptr SXElement' -> IO (Ptr SXElement')
casadi__SXElement__sqrt
  :: SXElement -> IO SXElement
casadi__SXElement__sqrt x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement__sqrt errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- 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__sym" c_casadi__SXElement__sym
  :: Ptr (Ptr StdString) -> Ptr StdString -> IO (Ptr SXElement')
casadi__SXElement__sym
  :: String -> IO SXElement
casadi__SXElement__sym x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement__sym errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


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


-- direct wrapper
foreign import ccall unsafe "casadi__SXElement__tan" c_casadi__SXElement__tan
  :: Ptr (Ptr StdString) -> Ptr SXElement' -> IO (Ptr SXElement')
casadi__SXElement__tan
  :: SXElement -> IO SXElement
casadi__SXElement__tan x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement__tan errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- 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__tanh" c_casadi__SXElement__tanh
  :: Ptr (Ptr StdString) -> Ptr SXElement' -> IO (Ptr SXElement')
casadi__SXElement__tanh
  :: SXElement -> IO SXElement
casadi__SXElement__tanh x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement__tanh errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- 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__trans" c_casadi__SXElement__trans
  :: Ptr (Ptr StdString) -> Ptr SXElement' -> IO (Ptr SXElement')
casadi__SXElement__trans
  :: SXElement -> IO SXElement
casadi__SXElement__trans x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement__trans errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- 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__unary" c_casadi__SXElement__unary
  :: Ptr (Ptr StdString) -> CInt -> Ptr SXElement' -> IO (Ptr SXElement')
casadi__SXElement__unary
  :: Int -> SXElement -> IO SXElement
casadi__SXElement__unary x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement__unary errStrPtrP x0' x1'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


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


-- direct wrapper
foreign import ccall unsafe "casadi__SXElement__getRepresentation" c_casadi__SXElement__getRepresentation
  :: Ptr (Ptr StdString) -> Ptr SXElement' -> IO (Ptr StdString)
casadi__SXElement__getRepresentation
  :: SXElement -> IO String
casadi__SXElement__getRepresentation x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement__getRepresentation errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sxElement_getRepresentation :: SXElementClass a => a -> IO String
sxElement_getRepresentation x = casadi__SXElement__getRepresentation (castSXElement x)


-- direct wrapper
foreign import ccall unsafe "casadi__SXElement__getDescription" c_casadi__SXElement__getDescription
  :: Ptr (Ptr StdString) -> Ptr SXElement' -> IO (Ptr StdString)
casadi__SXElement__getDescription
  :: SXElement -> IO String
casadi__SXElement__getDescription x0 =
  withMarshal x0 $ \x0' ->
  do
    errStrPtrP <- new nullPtr
    ret <- c_casadi__SXElement__getDescription errStrPtrP x0'
    errStrPtr <- peek errStrPtrP
    free errStrPtrP
    if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)


-- classy wrapper
sxElement_getDescription :: SXElementClass a => a -> IO String
sxElement_getDescription x = casadi__SXElement__getDescription (castSXElement x)