casadi-bindings-1.8.2.1: Casadi/Wrappers/Classes/SX.hs

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

module Casadi.Wrappers.Classes.SX
       (
         SX,
         SXClass(..),
         sx,
         sx',
         sx'',
         sx___add__,
         sx___constpow__,
         sx___div__,
         sx___eq__,
         sx___hash__,
         sx___le__,
         sx___lt__,
         sx___mpower__,
         sx___mrdivide__,
         sx___mul__,
         sx___ne__,
         sx___nonzero__,
         sx___pow__,
         sx___sub__,
         sx___truediv__,
         sx_arccos,
         sx_arccosh,
         sx_arcsin,
         sx_arcsinh,
         sx_arctan,
         sx_arctan2,
         sx_arctan2',
         sx_arctanh,
         sx_assignIfDuplicate,
         sx_assignIfDuplicate',
         sx_binary,
         sx_ceil,
         sx_constpow,
         sx_constpow',
         sx_cos,
         sx_cosh,
         sx_erf,
         sx_erfinv,
         sx_exp,
         sx_fabs,
         sx_floor,
         sx_fmax,
         sx_fmax',
         sx_fmin,
         sx_fmin',
         sx_getDep,
         sx_getDep',
         sx_getEqualityCheckingDepth,
         sx_getIntValue,
         sx_getMaxNumCallsInPrint,
         sx_getNdeps,
         sx_getOp,
         sx_getTemp,
         sx_getValue,
         sx_hasDep,
         sx_if_else_zero,
         sx_inv,
         sx_isCommutative,
         sx_isConstant,
         sx_isDoubled,
         sx_isEqual,
         sx_isEqual',
         sx_isInf,
         sx_isInteger,
         sx_isLeaf,
         sx_isMinusInf,
         sx_isMinusOne,
         sx_isNan,
         sx_isNonNegative,
         sx_isNull,
         sx_isOne,
         sx_isOp,
         sx_isSymbolic,
         sx_isZero,
         sx_log,
         sx_log10,
         sx_logic_and,
         sx_logic_not,
         sx_logic_or,
         sx_mark,
         sx_marked,
         sx_mul,
         sx_operator_minus,
         sx_printme,
         sx_setEqualityCheckingDepth,
         sx_setEqualityCheckingDepth',
         sx_setMaxNumCallsInPrint,
         sx_setMaxNumCallsInPrint',
         sx_setTemp,
         sx_sign,
         sx_sin,
         sx_sinh,
         sx_sq,
         sx_sqrt,
         sx_tan,
         sx_tanh,
         sx_trans,
         sx_unary,
       ) where


import Prelude hiding ( Functor )

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

import Casadi.Wrappers.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__SX__binary" c_CasADi__SX__binary
  :: CInt -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
casADi__SX__binary
  :: Int -> SX -> SX -> IO SX
casADi__SX__binary x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__SX__binary x0' x1' x2' >>= wrapReturn

-- classy wrapper
sx_binary :: Int -> SX -> SX -> IO SX
sx_binary = casADi__SX__binary


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

-- classy wrapper
sx_unary :: Int -> SX -> IO SX
sx_unary = casADi__SX__unary


-- direct wrapper
foreign import ccall unsafe "CasADi__SX____nonzero__" c_CasADi__SX____nonzero__
  :: Ptr SX' -> IO CInt
casADi__SX____nonzero__
  :: SX -> IO Bool
casADi__SX____nonzero__ x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SX____nonzero__ x0' >>= wrapReturn

-- classy wrapper
{-|
>Check the truth value of this node Introduced to catch bool(x) situations in
>python.
-}
sx___nonzero__ :: SXClass a => a -> IO Bool
sx___nonzero__ x = casADi__SX____nonzero__ (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SX__isLeaf" c_CasADi__SX__isLeaf
  :: Ptr SX' -> IO CInt
casADi__SX__isLeaf
  :: SX -> IO Bool
casADi__SX__isLeaf x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SX__isLeaf x0' >>= wrapReturn

-- classy wrapper
{-|
>check if this SX is a leaf of the SX graph
>
>An SX qualifies as leaf when it has no dependencies.
-}
sx_isLeaf :: SXClass a => a -> IO Bool
sx_isLeaf x = casADi__SX__isLeaf (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SX__isConstant" c_CasADi__SX__isConstant
  :: Ptr SX' -> IO CInt
casADi__SX__isConstant
  :: SX -> IO Bool
casADi__SX__isConstant x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SX__isConstant x0' >>= wrapReturn

-- classy wrapper
sx_isConstant :: SXClass a => a -> IO Bool
sx_isConstant x = casADi__SX__isConstant (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SX__isInteger" c_CasADi__SX__isInteger
  :: Ptr SX' -> IO CInt
casADi__SX__isInteger
  :: SX -> IO Bool
casADi__SX__isInteger x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SX__isInteger x0' >>= wrapReturn

-- classy wrapper
sx_isInteger :: SXClass a => a -> IO Bool
sx_isInteger x = casADi__SX__isInteger (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SX__isSymbolic" c_CasADi__SX__isSymbolic
  :: Ptr SX' -> IO CInt
casADi__SX__isSymbolic
  :: SX -> IO Bool
casADi__SX__isSymbolic x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SX__isSymbolic x0' >>= wrapReturn

-- classy wrapper
sx_isSymbolic :: SXClass a => a -> IO Bool
sx_isSymbolic x = casADi__SX__isSymbolic (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SX__hasDep" c_CasADi__SX__hasDep
  :: Ptr SX' -> IO CInt
casADi__SX__hasDep
  :: SX -> IO Bool
casADi__SX__hasDep x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SX__hasDep x0' >>= wrapReturn

-- classy wrapper
sx_hasDep :: SXClass a => a -> IO Bool
sx_hasDep x = casADi__SX__hasDep (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SX__isCommutative" c_CasADi__SX__isCommutative
  :: Ptr SX' -> IO CInt
casADi__SX__isCommutative
  :: SX -> IO Bool
casADi__SX__isCommutative x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SX__isCommutative x0' >>= wrapReturn

-- classy wrapper
{-|
>Check wether a binary SX is commutative.
-}
sx_isCommutative :: SXClass a => a -> IO Bool
sx_isCommutative x = casADi__SX__isCommutative (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SX__isZero" c_CasADi__SX__isZero
  :: Ptr SX' -> IO CInt
casADi__SX__isZero
  :: SX -> IO Bool
casADi__SX__isZero x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SX__isZero x0' >>= wrapReturn

-- classy wrapper
sx_isZero :: SXClass a => a -> IO Bool
sx_isZero x = casADi__SX__isZero (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SX__isOne" c_CasADi__SX__isOne
  :: Ptr SX' -> IO CInt
casADi__SX__isOne
  :: SX -> IO Bool
casADi__SX__isOne x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SX__isOne x0' >>= wrapReturn

-- classy wrapper
sx_isOne :: SXClass a => a -> IO Bool
sx_isOne x = casADi__SX__isOne (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SX__isMinusOne" c_CasADi__SX__isMinusOne
  :: Ptr SX' -> IO CInt
casADi__SX__isMinusOne
  :: SX -> IO Bool
casADi__SX__isMinusOne x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SX__isMinusOne x0' >>= wrapReturn

-- classy wrapper
sx_isMinusOne :: SXClass a => a -> IO Bool
sx_isMinusOne x = casADi__SX__isMinusOne (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SX__isNan" c_CasADi__SX__isNan
  :: Ptr SX' -> IO CInt
casADi__SX__isNan
  :: SX -> IO Bool
casADi__SX__isNan x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SX__isNan x0' >>= wrapReturn

-- classy wrapper
sx_isNan :: SXClass a => a -> IO Bool
sx_isNan x = casADi__SX__isNan (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SX__isInf" c_CasADi__SX__isInf
  :: Ptr SX' -> IO CInt
casADi__SX__isInf
  :: SX -> IO Bool
casADi__SX__isInf x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SX__isInf x0' >>= wrapReturn

-- classy wrapper
sx_isInf :: SXClass a => a -> IO Bool
sx_isInf x = casADi__SX__isInf (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SX__isMinusInf" c_CasADi__SX__isMinusInf
  :: Ptr SX' -> IO CInt
casADi__SX__isMinusInf
  :: SX -> IO Bool
casADi__SX__isMinusInf x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SX__isMinusInf x0' >>= wrapReturn

-- classy wrapper
sx_isMinusInf :: SXClass a => a -> IO Bool
sx_isMinusInf x = casADi__SX__isMinusInf (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SX__getOp" c_CasADi__SX__getOp
  :: Ptr SX' -> IO CInt
casADi__SX__getOp
  :: SX -> IO Int
casADi__SX__getOp x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SX__getOp x0' >>= wrapReturn

-- classy wrapper
sx_getOp :: SXClass a => a -> IO Int
sx_getOp x = casADi__SX__getOp (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SX__isOp" c_CasADi__SX__isOp
  :: Ptr SX' -> CInt -> IO CInt
casADi__SX__isOp
  :: SX -> Int -> IO Bool
casADi__SX__isOp x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__SX__isOp x0' x1' >>= wrapReturn

-- classy wrapper
sx_isOp :: SXClass a => a -> Int -> IO Bool
sx_isOp x = casADi__SX__isOp (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SX__isEqual" c_CasADi__SX__isEqual
  :: Ptr SX' -> Ptr SX' -> CInt -> IO CInt
casADi__SX__isEqual
  :: SX -> SX -> Int -> IO Bool
casADi__SX__isEqual x0 x1 x2 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  withMarshal x2 $ \x2' ->
  c_CasADi__SX__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
-}
sx_isEqual :: SXClass a => a -> SX -> Int -> IO Bool
sx_isEqual x = casADi__SX__isEqual (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SX__isEqual_TIC" c_CasADi__SX__isEqual_TIC
  :: Ptr SX' -> Ptr SX' -> IO CInt
casADi__SX__isEqual'
  :: SX -> SX -> IO Bool
casADi__SX__isEqual' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__SX__isEqual_TIC x0' x1' >>= wrapReturn

-- classy wrapper
sx_isEqual' :: SXClass a => a -> SX -> IO Bool
sx_isEqual' x = casADi__SX__isEqual' (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SX__isNonNegative" c_CasADi__SX__isNonNegative
  :: Ptr SX' -> IO CInt
casADi__SX__isNonNegative
  :: SX -> IO Bool
casADi__SX__isNonNegative x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SX__isNonNegative x0' >>= wrapReturn

-- classy wrapper
{-|
>Check if a value is always nonnegative (false negatives are allowed)
-}
sx_isNonNegative :: SXClass a => a -> IO Bool
sx_isNonNegative x = casADi__SX__isNonNegative (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SX__getValue" c_CasADi__SX__getValue
  :: Ptr SX' -> IO CDouble
casADi__SX__getValue
  :: SX -> IO Double
casADi__SX__getValue x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SX__getValue x0' >>= wrapReturn

-- classy wrapper
sx_getValue :: SXClass a => a -> IO Double
sx_getValue x = casADi__SX__getValue (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SX__getIntValue" c_CasADi__SX__getIntValue
  :: Ptr SX' -> IO CInt
casADi__SX__getIntValue
  :: SX -> IO Int
casADi__SX__getIntValue x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SX__getIntValue x0' >>= wrapReturn

-- classy wrapper
sx_getIntValue :: SXClass a => a -> IO Int
sx_getIntValue x = casADi__SX__getIntValue (castSX x)


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

-- classy wrapper
sx_getDep :: SXClass a => a -> Int -> IO SX
sx_getDep x = casADi__SX__getDep (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SX__getDep_TIC" c_CasADi__SX__getDep_TIC
  :: Ptr SX' -> IO (Ptr SX')
casADi__SX__getDep'
  :: SX -> IO SX
casADi__SX__getDep' x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SX__getDep_TIC x0' >>= wrapReturn

-- classy wrapper
sx_getDep' :: SXClass a => a -> IO SX
sx_getDep' x = casADi__SX__getDep' (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SX__isDoubled" c_CasADi__SX__isDoubled
  :: Ptr SX' -> IO CInt
casADi__SX__isDoubled
  :: SX -> IO Bool
casADi__SX__isDoubled x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SX__isDoubled x0' >>= wrapReturn

-- classy wrapper
{-|
>Check if the node is the sum of two equal expressions.
-}
sx_isDoubled :: SXClass a => a -> IO Bool
sx_isDoubled x = casADi__SX__isDoubled (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SX__getNdeps" c_CasADi__SX__getNdeps
  :: Ptr SX' -> IO CInt
casADi__SX__getNdeps
  :: SX -> IO Int
casADi__SX__getNdeps x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SX__getNdeps x0' >>= wrapReturn

-- classy wrapper
{-|
>Get the number of dependencies of a binary SX.
-}
sx_getNdeps :: SXClass a => a -> IO Int
sx_getNdeps x = casADi__SX__getNdeps (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SX____hash__" c_CasADi__SX____hash__
  :: Ptr SX' -> IO CLong
casADi__SX____hash__
  :: SX -> IO Int
casADi__SX____hash__ x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SX____hash__ x0' >>= wrapReturn

-- classy wrapper
{-|
>Returns a number that is unique for a given SXNode. If the SX does not point
>to any node, 0 is returned.
-}
sx___hash__ :: SXClass a => a -> IO Int
sx___hash__ x = casADi__SX____hash__ (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SX__operator_minus" c_CasADi__SX__operator_minus
  :: Ptr SX' -> IO (Ptr SX')
casADi__SX__operator_minus
  :: SX -> IO SX
casADi__SX__operator_minus x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SX__operator_minus x0' >>= wrapReturn

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


-- direct wrapper
foreign import ccall unsafe "CasADi__SX____add__" c_CasADi__SX____add__
  :: Ptr SX' -> Ptr SX' -> IO (Ptr SX')
casADi__SX____add__
  :: SX -> SX -> IO SX
casADi__SX____add__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__SX____add__ x0' x1' >>= wrapReturn

-- classy wrapper
sx___add__ :: SXClass a => a -> SX -> IO SX
sx___add__ x = casADi__SX____add__ (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SX____sub__" c_CasADi__SX____sub__
  :: Ptr SX' -> Ptr SX' -> IO (Ptr SX')
casADi__SX____sub__
  :: SX -> SX -> IO SX
casADi__SX____sub__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__SX____sub__ x0' x1' >>= wrapReturn

-- classy wrapper
sx___sub__ :: SXClass a => a -> SX -> IO SX
sx___sub__ x = casADi__SX____sub__ (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SX____mul__" c_CasADi__SX____mul__
  :: Ptr SX' -> Ptr SX' -> IO (Ptr SX')
casADi__SX____mul__
  :: SX -> SX -> IO SX
casADi__SX____mul__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__SX____mul__ x0' x1' >>= wrapReturn

-- classy wrapper
sx___mul__ :: SXClass a => a -> SX -> IO SX
sx___mul__ x = casADi__SX____mul__ (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SX____div__" c_CasADi__SX____div__
  :: Ptr SX' -> Ptr SX' -> IO (Ptr SX')
casADi__SX____div__
  :: SX -> SX -> IO SX
casADi__SX____div__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__SX____div__ x0' x1' >>= wrapReturn

-- classy wrapper
sx___div__ :: SXClass a => a -> SX -> IO SX
sx___div__ x = casADi__SX____div__ (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SX____lt__" c_CasADi__SX____lt__
  :: Ptr SX' -> Ptr SX' -> IO (Ptr SX')
casADi__SX____lt__
  :: SX -> SX -> IO SX
casADi__SX____lt__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__SX____lt__ x0' x1' >>= wrapReturn

-- classy wrapper
sx___lt__ :: SXClass a => a -> SX -> IO SX
sx___lt__ x = casADi__SX____lt__ (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SX____le__" c_CasADi__SX____le__
  :: Ptr SX' -> Ptr SX' -> IO (Ptr SX')
casADi__SX____le__
  :: SX -> SX -> IO SX
casADi__SX____le__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__SX____le__ x0' x1' >>= wrapReturn

-- classy wrapper
sx___le__ :: SXClass a => a -> SX -> IO SX
sx___le__ x = casADi__SX____le__ (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SX____eq__" c_CasADi__SX____eq__
  :: Ptr SX' -> Ptr SX' -> IO (Ptr SX')
casADi__SX____eq__
  :: SX -> SX -> IO SX
casADi__SX____eq__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__SX____eq__ x0' x1' >>= wrapReturn

-- classy wrapper
sx___eq__ :: SXClass a => a -> SX -> IO SX
sx___eq__ x = casADi__SX____eq__ (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SX____ne__" c_CasADi__SX____ne__
  :: Ptr SX' -> Ptr SX' -> IO (Ptr SX')
casADi__SX____ne__
  :: SX -> SX -> IO SX
casADi__SX____ne__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__SX____ne__ x0' x1' >>= wrapReturn

-- classy wrapper
sx___ne__ :: SXClass a => a -> SX -> IO SX
sx___ne__ x = casADi__SX____ne__ (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SX____truediv__" c_CasADi__SX____truediv__
  :: Ptr SX' -> Ptr SX' -> IO (Ptr SX')
casADi__SX____truediv__
  :: SX -> SX -> IO SX
casADi__SX____truediv__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__SX____truediv__ x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>Division (with future.division in effect)
-}
sx___truediv__ :: SXClass a => a -> SX -> IO SX
sx___truediv__ x = casADi__SX____truediv__ (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SX____pow__" c_CasADi__SX____pow__
  :: Ptr SX' -> Ptr SX' -> IO (Ptr SX')
casADi__SX____pow__
  :: SX -> SX -> IO SX
casADi__SX____pow__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__SX____pow__ x0' x1' >>= wrapReturn

-- classy wrapper
sx___pow__ :: SXClass a => a -> SX -> IO SX
sx___pow__ x = casADi__SX____pow__ (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SX____constpow__" c_CasADi__SX____constpow__
  :: Ptr SX' -> Ptr SX' -> IO (Ptr SX')
casADi__SX____constpow__
  :: SX -> SX -> IO SX
casADi__SX____constpow__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__SX____constpow__ x0' x1' >>= wrapReturn

-- classy wrapper
sx___constpow__ :: SXClass a => a -> SX -> IO SX
sx___constpow__ x = casADi__SX____constpow__ (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SX____mrdivide__" c_CasADi__SX____mrdivide__
  :: Ptr SX' -> Ptr SX' -> IO (Ptr SX')
casADi__SX____mrdivide__
  :: SX -> SX -> IO SX
casADi__SX____mrdivide__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__SX____mrdivide__ x0' x1' >>= wrapReturn

-- classy wrapper
sx___mrdivide__ :: SXClass a => a -> SX -> IO SX
sx___mrdivide__ x = casADi__SX____mrdivide__ (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SX____mpower__" c_CasADi__SX____mpower__
  :: Ptr SX' -> Ptr SX' -> IO (Ptr SX')
casADi__SX____mpower__
  :: SX -> SX -> IO SX
casADi__SX____mpower__ x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__SX____mpower__ x0' x1' >>= wrapReturn

-- classy wrapper
sx___mpower__ :: SXClass a => a -> SX -> IO SX
sx___mpower__ x = casADi__SX____mpower__ (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SX__trans" c_CasADi__SX__trans
  :: Ptr SX' -> IO (Ptr SX')
casADi__SX__trans
  :: SX -> IO SX
casADi__SX__trans x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SX__trans x0' >>= wrapReturn

-- classy wrapper
sx_trans :: SXClass a => a -> IO SX
sx_trans x = casADi__SX__trans (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SX__mul" c_CasADi__SX__mul
  :: Ptr SX' -> Ptr SX' -> IO (Ptr SX')
casADi__SX__mul
  :: SX -> SX -> IO SX
casADi__SX__mul x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__SX__mul x0' x1' >>= wrapReturn

-- classy wrapper
{-|
>The following functions serves two purposes: Numpy compatibility and to
>allow unambigous access.
-}
sx_mul :: SXClass a => a -> SX -> IO SX
sx_mul x = casADi__SX__mul (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SX__exp" c_CasADi__SX__exp
  :: Ptr SX' -> IO (Ptr SX')
casADi__SX__exp
  :: SX -> IO SX
casADi__SX__exp x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SX__exp x0' >>= wrapReturn

-- classy wrapper
sx_exp :: SXClass a => a -> IO SX
sx_exp x = casADi__SX__exp (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SX__log" c_CasADi__SX__log
  :: Ptr SX' -> IO (Ptr SX')
casADi__SX__log
  :: SX -> IO SX
casADi__SX__log x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SX__log x0' >>= wrapReturn

-- classy wrapper
sx_log :: SXClass a => a -> IO SX
sx_log x = casADi__SX__log (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SX__sqrt" c_CasADi__SX__sqrt
  :: Ptr SX' -> IO (Ptr SX')
casADi__SX__sqrt
  :: SX -> IO SX
casADi__SX__sqrt x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SX__sqrt x0' >>= wrapReturn

-- classy wrapper
sx_sqrt :: SXClass a => a -> IO SX
sx_sqrt x = casADi__SX__sqrt (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SX__sq" c_CasADi__SX__sq
  :: Ptr SX' -> IO (Ptr SX')
casADi__SX__sq
  :: SX -> IO SX
casADi__SX__sq x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SX__sq x0' >>= wrapReturn

-- classy wrapper
sx_sq :: SXClass a => a -> IO SX
sx_sq x = casADi__SX__sq (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SX__sin" c_CasADi__SX__sin
  :: Ptr SX' -> IO (Ptr SX')
casADi__SX__sin
  :: SX -> IO SX
casADi__SX__sin x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SX__sin x0' >>= wrapReturn

-- classy wrapper
sx_sin :: SXClass a => a -> IO SX
sx_sin x = casADi__SX__sin (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SX__cos" c_CasADi__SX__cos
  :: Ptr SX' -> IO (Ptr SX')
casADi__SX__cos
  :: SX -> IO SX
casADi__SX__cos x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SX__cos x0' >>= wrapReturn

-- classy wrapper
sx_cos :: SXClass a => a -> IO SX
sx_cos x = casADi__SX__cos (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SX__tan" c_CasADi__SX__tan
  :: Ptr SX' -> IO (Ptr SX')
casADi__SX__tan
  :: SX -> IO SX
casADi__SX__tan x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SX__tan x0' >>= wrapReturn

-- classy wrapper
sx_tan :: SXClass a => a -> IO SX
sx_tan x = casADi__SX__tan (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SX__arcsin" c_CasADi__SX__arcsin
  :: Ptr SX' -> IO (Ptr SX')
casADi__SX__arcsin
  :: SX -> IO SX
casADi__SX__arcsin x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SX__arcsin x0' >>= wrapReturn

-- classy wrapper
sx_arcsin :: SXClass a => a -> IO SX
sx_arcsin x = casADi__SX__arcsin (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SX__arccos" c_CasADi__SX__arccos
  :: Ptr SX' -> IO (Ptr SX')
casADi__SX__arccos
  :: SX -> IO SX
casADi__SX__arccos x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SX__arccos x0' >>= wrapReturn

-- classy wrapper
sx_arccos :: SXClass a => a -> IO SX
sx_arccos x = casADi__SX__arccos (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SX__arctan" c_CasADi__SX__arctan
  :: Ptr SX' -> IO (Ptr SX')
casADi__SX__arctan
  :: SX -> IO SX
casADi__SX__arctan x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SX__arctan x0' >>= wrapReturn

-- classy wrapper
sx_arctan :: SXClass a => a -> IO SX
sx_arctan x = casADi__SX__arctan (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SX__floor" c_CasADi__SX__floor
  :: Ptr SX' -> IO (Ptr SX')
casADi__SX__floor
  :: SX -> IO SX
casADi__SX__floor x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SX__floor x0' >>= wrapReturn

-- classy wrapper
sx_floor :: SXClass a => a -> IO SX
sx_floor x = casADi__SX__floor (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SX__ceil" c_CasADi__SX__ceil
  :: Ptr SX' -> IO (Ptr SX')
casADi__SX__ceil
  :: SX -> IO SX
casADi__SX__ceil x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SX__ceil x0' >>= wrapReturn

-- classy wrapper
sx_ceil :: SXClass a => a -> IO SX
sx_ceil x = casADi__SX__ceil (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SX__erf" c_CasADi__SX__erf
  :: Ptr SX' -> IO (Ptr SX')
casADi__SX__erf
  :: SX -> IO SX
casADi__SX__erf x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SX__erf x0' >>= wrapReturn

-- classy wrapper
sx_erf :: SXClass a => a -> IO SX
sx_erf x = casADi__SX__erf (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SX__erfinv" c_CasADi__SX__erfinv
  :: Ptr SX' -> IO (Ptr SX')
casADi__SX__erfinv
  :: SX -> IO SX
casADi__SX__erfinv x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SX__erfinv x0' >>= wrapReturn

-- classy wrapper
sx_erfinv :: SXClass a => a -> IO SX
sx_erfinv x = casADi__SX__erfinv (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SX__fabs" c_CasADi__SX__fabs
  :: Ptr SX' -> IO (Ptr SX')
casADi__SX__fabs
  :: SX -> IO SX
casADi__SX__fabs x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SX__fabs x0' >>= wrapReturn

-- classy wrapper
sx_fabs :: SXClass a => a -> IO SX
sx_fabs x = casADi__SX__fabs (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SX__fmin" c_CasADi__SX__fmin
  :: Ptr SX' -> Ptr SX' -> IO (Ptr SX')
casADi__SX__fmin
  :: SX -> SX -> IO SX
casADi__SX__fmin x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__SX__fmin x0' x1' >>= wrapReturn

-- classy wrapper
sx_fmin :: SXClass a => a -> SX -> IO SX
sx_fmin x = casADi__SX__fmin (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SX__fmax" c_CasADi__SX__fmax
  :: Ptr SX' -> Ptr SX' -> IO (Ptr SX')
casADi__SX__fmax
  :: SX -> SX -> IO SX
casADi__SX__fmax x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__SX__fmax x0' x1' >>= wrapReturn

-- classy wrapper
sx_fmax :: SXClass a => a -> SX -> IO SX
sx_fmax x = casADi__SX__fmax (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SX__inv" c_CasADi__SX__inv
  :: Ptr SX' -> IO (Ptr SX')
casADi__SX__inv
  :: SX -> IO SX
casADi__SX__inv x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SX__inv x0' >>= wrapReturn

-- classy wrapper
sx_inv :: SXClass a => a -> IO SX
sx_inv x = casADi__SX__inv (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SX__sinh" c_CasADi__SX__sinh
  :: Ptr SX' -> IO (Ptr SX')
casADi__SX__sinh
  :: SX -> IO SX
casADi__SX__sinh x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SX__sinh x0' >>= wrapReturn

-- classy wrapper
sx_sinh :: SXClass a => a -> IO SX
sx_sinh x = casADi__SX__sinh (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SX__cosh" c_CasADi__SX__cosh
  :: Ptr SX' -> IO (Ptr SX')
casADi__SX__cosh
  :: SX -> IO SX
casADi__SX__cosh x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SX__cosh x0' >>= wrapReturn

-- classy wrapper
sx_cosh :: SXClass a => a -> IO SX
sx_cosh x = casADi__SX__cosh (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SX__tanh" c_CasADi__SX__tanh
  :: Ptr SX' -> IO (Ptr SX')
casADi__SX__tanh
  :: SX -> IO SX
casADi__SX__tanh x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SX__tanh x0' >>= wrapReturn

-- classy wrapper
sx_tanh :: SXClass a => a -> IO SX
sx_tanh x = casADi__SX__tanh (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SX__arcsinh" c_CasADi__SX__arcsinh
  :: Ptr SX' -> IO (Ptr SX')
casADi__SX__arcsinh
  :: SX -> IO SX
casADi__SX__arcsinh x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SX__arcsinh x0' >>= wrapReturn

-- classy wrapper
sx_arcsinh :: SXClass a => a -> IO SX
sx_arcsinh x = casADi__SX__arcsinh (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SX__arccosh" c_CasADi__SX__arccosh
  :: Ptr SX' -> IO (Ptr SX')
casADi__SX__arccosh
  :: SX -> IO SX
casADi__SX__arccosh x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SX__arccosh x0' >>= wrapReturn

-- classy wrapper
sx_arccosh :: SXClass a => a -> IO SX
sx_arccosh x = casADi__SX__arccosh (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SX__arctanh" c_CasADi__SX__arctanh
  :: Ptr SX' -> IO (Ptr SX')
casADi__SX__arctanh
  :: SX -> IO SX
casADi__SX__arctanh x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SX__arctanh x0' >>= wrapReturn

-- classy wrapper
sx_arctanh :: SXClass a => a -> IO SX
sx_arctanh x = casADi__SX__arctanh (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SX__arctan2" c_CasADi__SX__arctan2
  :: Ptr SX' -> Ptr SX' -> IO (Ptr SX')
casADi__SX__arctan2
  :: SX -> SX -> IO SX
casADi__SX__arctan2 x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__SX__arctan2 x0' x1' >>= wrapReturn

-- classy wrapper
sx_arctan2 :: SXClass a => a -> SX -> IO SX
sx_arctan2 x = casADi__SX__arctan2 (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SX__log10" c_CasADi__SX__log10
  :: Ptr SX' -> IO (Ptr SX')
casADi__SX__log10
  :: SX -> IO SX
casADi__SX__log10 x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SX__log10 x0' >>= wrapReturn

-- classy wrapper
sx_log10 :: SXClass a => a -> IO SX
sx_log10 x = casADi__SX__log10 (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SX__printme" c_CasADi__SX__printme
  :: Ptr SX' -> Ptr SX' -> IO (Ptr SX')
casADi__SX__printme
  :: SX -> SX -> IO SX
casADi__SX__printme x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__SX__printme x0' x1' >>= wrapReturn

-- classy wrapper
sx_printme :: SXClass a => a -> SX -> IO SX
sx_printme x = casADi__SX__printme (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SX__sign" c_CasADi__SX__sign
  :: Ptr SX' -> IO (Ptr SX')
casADi__SX__sign
  :: SX -> IO SX
casADi__SX__sign x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SX__sign x0' >>= wrapReturn

-- classy wrapper
sx_sign :: SXClass a => a -> IO SX
sx_sign x = casADi__SX__sign (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SX__constpow" c_CasADi__SX__constpow
  :: Ptr SX' -> Ptr SX' -> IO (Ptr SX')
casADi__SX__constpow
  :: SX -> SX -> IO SX
casADi__SX__constpow x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__SX__constpow x0' x1' >>= wrapReturn

-- classy wrapper
sx_constpow :: SXClass a => a -> SX -> IO SX
sx_constpow x = casADi__SX__constpow (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SX__logic_not" c_CasADi__SX__logic_not
  :: Ptr SX' -> IO (Ptr SX')
casADi__SX__logic_not
  :: SX -> IO SX
casADi__SX__logic_not x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SX__logic_not x0' >>= wrapReturn

-- classy wrapper
sx_logic_not :: SXClass a => a -> IO SX
sx_logic_not x = casADi__SX__logic_not (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SX__logic_and" c_CasADi__SX__logic_and
  :: Ptr SX' -> Ptr SX' -> IO (Ptr SX')
casADi__SX__logic_and
  :: SX -> SX -> IO SX
casADi__SX__logic_and x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__SX__logic_and x0' x1' >>= wrapReturn

-- classy wrapper
sx_logic_and :: SXClass a => a -> SX -> IO SX
sx_logic_and x = casADi__SX__logic_and (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SX__logic_or" c_CasADi__SX__logic_or
  :: Ptr SX' -> Ptr SX' -> IO (Ptr SX')
casADi__SX__logic_or
  :: SX -> SX -> IO SX
casADi__SX__logic_or x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__SX__logic_or x0' x1' >>= wrapReturn

-- classy wrapper
sx_logic_or :: SXClass a => a -> SX -> IO SX
sx_logic_or x = casADi__SX__logic_or (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SX__if_else_zero" c_CasADi__SX__if_else_zero
  :: Ptr SX' -> Ptr SX' -> IO (Ptr SX')
casADi__SX__if_else_zero
  :: SX -> SX -> IO SX
casADi__SX__if_else_zero x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__SX__if_else_zero x0' x1' >>= wrapReturn

-- classy wrapper
sx_if_else_zero :: SXClass a => a -> SX -> IO SX
sx_if_else_zero x = casADi__SX__if_else_zero (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SX__fmin_TIC" c_CasADi__SX__fmin_TIC
  :: Ptr SX' -> Ptr SXMatrix' -> IO (Ptr SXMatrix')
casADi__SX__fmin'
  :: SX -> SXMatrix -> IO SXMatrix
casADi__SX__fmin' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__SX__fmin_TIC x0' x1' >>= wrapReturn

-- classy wrapper
sx_fmin' :: SXClass a => a -> SXMatrix -> IO SXMatrix
sx_fmin' x = casADi__SX__fmin' (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SX__fmax_TIC" c_CasADi__SX__fmax_TIC
  :: Ptr SX' -> Ptr SXMatrix' -> IO (Ptr SXMatrix')
casADi__SX__fmax'
  :: SX -> SXMatrix -> IO SXMatrix
casADi__SX__fmax' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__SX__fmax_TIC x0' x1' >>= wrapReturn

-- classy wrapper
sx_fmax' :: SXClass a => a -> SXMatrix -> IO SXMatrix
sx_fmax' x = casADi__SX__fmax' (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SX__constpow_TIC" c_CasADi__SX__constpow_TIC
  :: Ptr SX' -> Ptr SXMatrix' -> IO (Ptr SXMatrix')
casADi__SX__constpow'
  :: SX -> SXMatrix -> IO SXMatrix
casADi__SX__constpow' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__SX__constpow_TIC x0' x1' >>= wrapReturn

-- classy wrapper
sx_constpow' :: SXClass a => a -> SXMatrix -> IO SXMatrix
sx_constpow' x = casADi__SX__constpow' (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SX__arctan2_TIC" c_CasADi__SX__arctan2_TIC
  :: Ptr SX' -> Ptr SXMatrix' -> IO (Ptr SXMatrix')
casADi__SX__arctan2'
  :: SX -> SXMatrix -> IO SXMatrix
casADi__SX__arctan2' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__SX__arctan2_TIC x0' x1' >>= wrapReturn

-- classy wrapper
sx_arctan2' :: SXClass a => a -> SXMatrix -> IO SXMatrix
sx_arctan2' x = casADi__SX__arctan2' (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SX__getTemp" c_CasADi__SX__getTemp
  :: Ptr SX' -> IO CInt
casADi__SX__getTemp
  :: SX -> IO Int
casADi__SX__getTemp x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SX__getTemp x0' >>= wrapReturn

-- classy wrapper
sx_getTemp :: SXClass a => a -> IO Int
sx_getTemp x = casADi__SX__getTemp (castSX x)


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

-- classy wrapper
sx_setTemp :: SXClass a => a -> Int -> IO ()
sx_setTemp x = casADi__SX__setTemp (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SX__marked" c_CasADi__SX__marked
  :: Ptr SX' -> IO CInt
casADi__SX__marked
  :: SX -> IO Bool
casADi__SX__marked x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SX__marked x0' >>= wrapReturn

-- classy wrapper
sx_marked :: SXClass a => a -> IO Bool
sx_marked x = casADi__SX__marked (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SX__mark" c_CasADi__SX__mark
  :: Ptr SX' -> IO ()
casADi__SX__mark
  :: SX -> IO ()
casADi__SX__mark x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SX__mark x0' >>= wrapReturn

-- classy wrapper
sx_mark :: SXClass a => a -> IO ()
sx_mark x = casADi__SX__mark (castSX x)


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

-- classy wrapper
{-|
>Assign to another expression, if a duplicate. Check for equality up to a
>given depth.
-}
sx_assignIfDuplicate :: SXClass a => a -> SX -> Int -> IO ()
sx_assignIfDuplicate x = casADi__SX__assignIfDuplicate (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SX__assignIfDuplicate_TIC" c_CasADi__SX__assignIfDuplicate_TIC
  :: Ptr SX' -> Ptr SX' -> IO ()
casADi__SX__assignIfDuplicate'
  :: SX -> SX -> IO ()
casADi__SX__assignIfDuplicate' x0 x1 =
  withMarshal x0 $ \x0' ->
  withMarshal x1 $ \x1' ->
  c_CasADi__SX__assignIfDuplicate_TIC x0' x1' >>= wrapReturn

-- classy wrapper
sx_assignIfDuplicate' :: SXClass a => a -> SX -> IO ()
sx_assignIfDuplicate' x = casADi__SX__assignIfDuplicate' (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SX__setMaxNumCallsInPrint" c_CasADi__SX__setMaxNumCallsInPrint
  :: CLong -> IO ()
casADi__SX__setMaxNumCallsInPrint
  :: Int -> IO ()
casADi__SX__setMaxNumCallsInPrint x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SX__setMaxNumCallsInPrint x0' >>= wrapReturn

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


-- direct wrapper
foreign import ccall unsafe "CasADi__SX__setMaxNumCallsInPrint_TIC" c_CasADi__SX__setMaxNumCallsInPrint_TIC
  :: IO ()
casADi__SX__setMaxNumCallsInPrint'
  :: IO ()
casADi__SX__setMaxNumCallsInPrint'  =
  c_CasADi__SX__setMaxNumCallsInPrint_TIC  >>= wrapReturn

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


-- direct wrapper
foreign import ccall unsafe "CasADi__SX__getMaxNumCallsInPrint" c_CasADi__SX__getMaxNumCallsInPrint
  :: IO CLong
casADi__SX__getMaxNumCallsInPrint
  :: IO Int
casADi__SX__getMaxNumCallsInPrint  =
  c_CasADi__SX__getMaxNumCallsInPrint  >>= wrapReturn

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


-- direct wrapper
foreign import ccall unsafe "CasADi__SX__setEqualityCheckingDepth" c_CasADi__SX__setEqualityCheckingDepth
  :: CInt -> IO ()
casADi__SX__setEqualityCheckingDepth
  :: Int -> IO ()
casADi__SX__setEqualityCheckingDepth x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SX__setEqualityCheckingDepth x0' >>= wrapReturn

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


-- direct wrapper
foreign import ccall unsafe "CasADi__SX__setEqualityCheckingDepth_TIC" c_CasADi__SX__setEqualityCheckingDepth_TIC
  :: IO ()
casADi__SX__setEqualityCheckingDepth'
  :: IO ()
casADi__SX__setEqualityCheckingDepth'  =
  c_CasADi__SX__setEqualityCheckingDepth_TIC  >>= wrapReturn

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


-- direct wrapper
foreign import ccall unsafe "CasADi__SX__getEqualityCheckingDepth" c_CasADi__SX__getEqualityCheckingDepth
  :: IO CInt
casADi__SX__getEqualityCheckingDepth
  :: IO Int
casADi__SX__getEqualityCheckingDepth  =
  c_CasADi__SX__getEqualityCheckingDepth  >>= wrapReturn

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


-- direct wrapper
foreign import ccall unsafe "CasADi__SX__isNull" c_CasADi__SX__isNull
  :: Ptr SX' -> IO CInt
casADi__SX__isNull
  :: SX -> IO Bool
casADi__SX__isNull x0 =
  withMarshal x0 $ \x0' ->
  c_CasADi__SX__isNull x0' >>= wrapReturn

-- classy wrapper
{-|
>SX nodes are not allowed to be null.
-}
sx_isNull :: SXClass a => a -> IO Bool
sx_isNull x = casADi__SX__isNull (castSX x)


-- direct wrapper
foreign import ccall unsafe "CasADi__SX__SX" c_CasADi__SX__SX
  :: IO (Ptr SX')
casADi__SX__SX
  :: IO SX
casADi__SX__SX  =
  c_CasADi__SX__SX  >>= wrapReturn

-- classy wrapper
{-|
>>  CasADi::SX::SX()
>------------------------------------------------------------------------
>
>Constructors.
>
>Default constructor (not-a-number)
>
>Object is initialised as not-a-number.
>
>>  CasADi::SX::SX(double val)
>------------------------------------------------------------------------
>
>Numerical constant constructor.
>
>Parameters:
>-----------
>
>val:  Numerical value
>
>>  CasADi::SX::SX(const std::string &name)
>------------------------------------------------------------------------
>
>Symbolic constructor.
>
>Parameters:
>-----------
>
>name:  Name of the symbol
>
>This is the name that wil be used by the "operator<<" and "toSTring"
>methods. The name is not used as identifier; you may construct distinct SX
>objects with non-unique names.
>
>>  CasADi::SX::SX(SXNode *node, bool dummy)
>------------------------------------------------------------------------
>
>Symbolic constructor.
>
>Parameters:
>-----------
>
>Name:  of the symbol
>
>This is the name that wil be used by the "operator<<" and "toSTring"
>methods. The name is not used as identifier; you may construct distinct SX
>objects with non-unique names.Create an expression from a node: extra dummy
>argument to avoid ambigousity for 0/NULL
>
>>  CasADi::SX::SX(const SX &scalar)
>------------------------------------------------------------------------
>
>Copy constructor.
-}
sx :: IO SX
sx = casADi__SX__SX


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

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


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

-- classy wrapper
sx'' :: String -> IO SX
sx'' = casADi__SX__SX''