casadi-bindings (empty) → 1.8.0.0
raw patch · 40 files changed
+49376/−0 lines, 40 filesdep +basedep +vectorsetup-changed
Dependencies added: base, vector
Files
- Casadi/Callback.hs +53/−0
- Casadi/Marshal.hs +140/−0
- Casadi/MarshalTypes.hs +42/−0
- Casadi/WrapReturn.hs +134/−0
- Casadi/Wrappers/Classes/CRSSparsity.hs +728/−0
- Casadi/Wrappers/Classes/CSparse.hs +107/−0
- Casadi/Wrappers/Classes/Callback.hs +58/−0
- Casadi/Wrappers/Classes/CasadiMeta.hs +142/−0
- Casadi/Wrappers/Classes/CasadiOptions.hs +117/−0
- Casadi/Wrappers/Classes/CustomEvaluate.hs +58/−0
- Casadi/Wrappers/Classes/CustomFunction.hs +119/−0
- Casadi/Wrappers/Classes/DMatrix.hs +2681/−0
- Casadi/Wrappers/Classes/ExternalFunction.hs +93/−0
- Casadi/Wrappers/Classes/FX.hs +569/−0
- Casadi/Wrappers/Classes/Functor.hs +34/−0
- Casadi/Wrappers/Classes/GenericType.hs +576/−0
- Casadi/Wrappers/Classes/IOInterfaceFX.hs +558/−0
- Casadi/Wrappers/Classes/IOScheme.hs +336/−0
- Casadi/Wrappers/Classes/IpoptSolver.hs +131/−0
- Casadi/Wrappers/Classes/MX.hs +2327/−0
- Casadi/Wrappers/Classes/MXFunction.hs +253/−0
- Casadi/Wrappers/Classes/OptionsFunctionality.hs +403/−0
- Casadi/Wrappers/Classes/PrintableObject.hs +68/−0
- Casadi/Wrappers/Classes/SX.hs +1604/−0
- Casadi/Wrappers/Classes/SXFunction.hs +304/−0
- Casadi/Wrappers/Classes/SXMatrix.hs +2681/−0
- Casadi/Wrappers/Classes/SharedObject.hs +156/−0
- Casadi/Wrappers/Data.hs +4986/−0
- Casadi/Wrappers/Deleters.hs +249/−0
- Casadi/Wrappers/Enums.hs +1961/−0
- Casadi/Wrappers/ForeignToolsImports.hs +49/−0
- Casadi/Wrappers/ForeignToolsInstances.hs +30/−0
- Casadi/Wrappers/Tools.hs +4841/−0
- LICENSE +165/−0
- Setup.hs +2/−0
- casadi-bindings.cabal +97/−0
- cbits/autogen/all.cpp +22239/−0
- cbits/callback.cpp +56/−0
- cbits/hs_tools.cpp +123/−0
- cbits/marshal.hpp +106/−0
+ Casadi/Callback.hs view
@@ -0,0 +1,53 @@+{-# OPTIONS_GHC -Wall #-}+{-# Language ForeignFunctionInterface #-}++module Casadi.Callback ( makeCallback+ , fxSolveSafe+ ) where+++import Foreign.C.Types+import Foreign.Ptr ( Ptr, FunPtr )+import Foreign.ForeignPtr ( newForeignPtr, newForeignPtr_ )++import Casadi.Wrappers.ForeignToolsInstances ( )+import Casadi.Wrappers.Data+import Casadi.Marshal ( Marshal(..) )+import Casadi.WrapReturn ( WrapReturn(..) )++-- direct wrapper to a safe version of "solve"+foreign import ccall safe "CasADi__FX__solve" c_CasADi__FX__solve_safe+ :: Ptr FX' -> IO ()++casADi__FX__solve_safe :: FX -> IO ()+casADi__FX__solve_safe x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__FX__solve_safe x0' >>= wrapReturn++-- | safe version of solve+fxSolveSafe :: FXClass a => a -> IO ()+fxSolveSafe x = casADi__FX__solve_safe (castFX x)++type CasadiCallback' = Ptr FX' -> IO CInt+foreign import ccall "wrapper" mkCallback :: CasadiCallback' -> IO (FunPtr CasadiCallback')++foreign import ccall safe "new_callback_haskell" c_newCallbackHaskell+ :: FunPtr CasadiCallback' -> IO (Ptr Callback')++foreign import ccall safe "&delete_callback_haskell" c_deleteCallbackHaskell+ :: FunPtr (Ptr Callback' -> IO ())++-- | add a callback to an NLPSolver+makeCallback :: (FX -> IO CInt) -> IO Callback+makeCallback callback = do+ -- safely wrap the callback into the C-friendly version+ let callback' :: CasadiCallback'+ callback' ptrFx = do+ foreignCFun <- newForeignPtr_ ptrFx+ callback (FX foreignCFun)++ -- turn the callback into a FunPtr+ callbackFunPtr <- mkCallback callback' :: IO (FunPtr CasadiCallback')++ -- create the callback object+ c_newCallbackHaskell callbackFunPtr >>= (newForeignPtr c_deleteCallbackHaskell) >>= wrapReturn
+ Casadi/Marshal.hs view
@@ -0,0 +1,140 @@+{-# OPTIONS_GHC -Wall #-}+{-# Language MultiParamTypeClasses #-}+{-# Language TypeSynonymInstances #-}+{-# Language FlexibleInstances #-}+{-# Language FlexibleContexts #-}++module Casadi.Marshal ( Marshal(..)+ , HsToC(..)+ , CornerCase(..)+ , withMarshalStorableVec+ , withMarshalStorableVecVec+ ) where++import qualified Data.Vector as V+import Foreign.C.Types+import Foreign.C.String ( withCString )+import Foreign.Ptr ( Ptr )+import Foreign.Marshal ( withArray, withArrayLen )+import Foreign.Storable ( Storable )++import Casadi.Wrappers.ForeignToolsImports+import Casadi.MarshalTypes++class Marshal a b where+ withMarshal :: a -> (b -> IO c) -> IO c++class HsToC a b where+ hsToC :: a -> b+instance HsToC Int CInt where+ hsToC = fromIntegral -- really should check min/max bounds here+instance HsToC Int CLong where+ hsToC = fromIntegral+instance HsToC Bool CInt where+ hsToC True = 1+ hsToC False = 0+instance HsToC Double CDouble where+ hsToC = realToFrac+instance HsToC CUChar CUChar where+ hsToC = id+instance HsToC CSize CSize where+ hsToC = id++instance Marshal Int CInt where+ withMarshal x f = f (hsToC x)+instance Marshal Int CLong where+ withMarshal x f = f (hsToC x)+instance Marshal Bool CInt where+ withMarshal x f = f (hsToC x)+instance Marshal Double CDouble where+ withMarshal x f = f (hsToC x)+instance Marshal CUChar CUChar where+ withMarshal x f = f (hsToC x)+instance Marshal CSize CSize where+ withMarshal x f = f (hsToC x)++foreign import ccall unsafe "hs_new_bool" c_newBool+ :: CInt -> IO (Ptr CppBool')+foreign import ccall unsafe "hs_delete_bool" c_deleteBool+ :: Ptr CppBool' -> IO ()+foreign import ccall unsafe "hs_new_string" c_newStdString+ :: Ptr CChar -> IO (Ptr StdString')+foreign import ccall unsafe "hs_delete_string" c_deleteStdString+ :: Ptr StdString' -> IO ()++instance Marshal Bool (Ptr CppBool') where+ withMarshal x f = do+ boolPtr <- c_newBool (hsToC x)+ ret <- f boolPtr+ c_deleteBool boolPtr+ return ret++instance Marshal String (Ptr CChar) where+ withMarshal = withCString++instance Marshal String (Ptr StdString') where+ withMarshal str f = do+ stdStr <- newStdString str+ ret <- f stdStr+ c_deleteStdString stdStr+ return ret++newStdString :: String -> IO (Ptr StdString')+newStdString x = withCString x $ \cstring -> c_newStdString cstring++newtype CornerCase a = CornerCase a++instance Marshal (CornerCase (V.Vector String)) (Ptr (CppVec (Ptr StdString'))) where+ withMarshal (CornerCase strs) f = do+ stdStrs <- V.mapM newStdString strs+ ret <- withMarshalStorableVec c_newVecVoidP c_deleteVecVoidP stdStrs f+ V.mapM_ c_deleteStdString stdStrs+ return ret+ +instance Marshal (CornerCase (V.Vector Bool)) (Ptr (CppVec (Ptr CppBool'))) where+ withMarshal (CornerCase bools) f = do+ stdBools <- V.mapM (c_newBool . hsToC) bools+ ret <- withMarshalStorableVec c_newVecVoidP c_deleteVecVoidP stdBools f+ V.mapM_ c_deleteBool stdBools+ return ret+ +instance ForeignPtrWrapper a b => Marshal (V.Vector a) (Ptr (CppVec (Ptr b))) where+ withMarshal vec f =+ let foreignPtrList = map unwrapForeignPtr (V.toList vec)+ in withForeignPtrs foreignPtrList $ \ptrList ->+ withMarshalStorableVec c_newVecVoidP c_deleteVecVoidP (V.fromList ptrList) f++instance ForeignPtrWrapper a b => Marshal (V.Vector (V.Vector a)) (Ptr (CppVecVec (Ptr b))) where+ withMarshal vecVec f =+ let foreignVecVec' = V.map (V.map unwrapForeignPtr) vecVec+ in withForeignPtrsVV foreignVecVec' $ \vecVec' ->+ withMarshalStorableVecVec c_newVecVecVoidP c_deleteVecVecVoidP vecVec' f++withMarshalStorableVec ::+ Storable a =>+ (Ptr a -> CInt -> IO (Ptr (CppVec a))) ->+ (Ptr (CppVec a) -> IO ()) ->+ V.Vector a -> (Ptr (CppVec a) -> IO b) -> IO b+withMarshalStorableVec newVec deleteVec vec f = do+ ptrCppVec <- withArrayLen (V.toList vec) $ \num array ->+ newVec array (fromIntegral num)+ ret <- f ptrCppVec+ deleteVec ptrCppVec+ return ret++withMarshalStorableVecVec ::+ Storable a =>+ (Ptr a -> CInt -> Ptr CInt -> IO (Ptr (CppVecVec a))) ->+ (Ptr (CppVecVec a) -> IO ()) ->+ V.Vector (V.Vector a) -> (Ptr (CppVecVec a) -> IO b) -> IO b+withMarshalStorableVecVec newVecVec deleteVecVec vecVec f = do+ let vecList = V.toList vecVec+ flatList = concatMap V.toList vecList+ innerLengths = map (fromIntegral . V.length) vecList+ outerLength = length innerLengths+ ptrCppVecVec <- withArray flatList $ \flatArray ->+ withArray innerLengths $ \innerLengthsArray ->+ newVecVec flatArray (fromIntegral outerLength) innerLengthsArray+ ret <- f ptrCppVecVec+ deleteVecVec ptrCppVecVec+ return ret
+ Casadi/MarshalTypes.hs view
@@ -0,0 +1,42 @@+{-# OPTIONS_GHC -Wall #-}+{-# Language MultiParamTypeClasses #-}+{-# Language FunctionalDependencies #-}++module Casadi.MarshalTypes ( ForeignPtrWrapper(..)+ , CppVec+ , CppVecVec+ , CppVecVecVec+ , StdString'+ , StdOstream'+ , CppBool'+ , withForeignPtrs+ , withForeignPtrsVV+ ) where++import qualified Data.Vector as V+import Foreign.Ptr ( Ptr )+import Foreign.ForeignPtr ( ForeignPtr, touchForeignPtr )+import Foreign.ForeignPtr.Unsafe ( unsafeForeignPtrToPtr )++data CppVec a+data CppVecVec a+data CppVecVecVec a++data StdString'+data StdOstream'+data CppBool'++class ForeignPtrWrapper a b | a -> b, b -> a where+ unwrapForeignPtr :: a -> ForeignPtr b++withForeignPtrs :: [ForeignPtr a] -> ([Ptr a] -> IO b) -> IO b+withForeignPtrs xs f = do+ ret <- f (map unsafeForeignPtrToPtr xs)+ mapM_ touchForeignPtr xs+ return ret++withForeignPtrsVV :: V.Vector (V.Vector (ForeignPtr a)) -> (V.Vector (V.Vector (Ptr a)) -> IO b) -> IO b+withForeignPtrsVV vv f = do+ ret <- f (V.map (V.map unsafeForeignPtrToPtr) vv)+ V.mapM_ (V.mapM_ touchForeignPtr) vv+ return ret
+ Casadi/WrapReturn.hs view
@@ -0,0 +1,134 @@+{-# OPTIONS_GHC -Wall #-}+{-# Language ForeignFunctionInterface #-}+{-# Language MultiParamTypeClasses #-}+{-# Language TypeSynonymInstances #-}+{-# Language FlexibleInstances #-}+{-# Language FlexibleContexts #-}++module Casadi.WrapReturn ( WrapReturn(..)+ ) where++import Control.Monad ( zipWithM )+import qualified Data.Vector as V+import Foreign.C.Types+import Foreign.C.String+import Foreign.Ptr ( Ptr )+import Foreign.Storable ( Storable )+import Foreign.ForeignPtr ( ForeignPtr, newForeignPtr_, withForeignPtr )+import Foreign.Marshal ( mallocArray, free, peekArray, withArray )++import Casadi.MarshalTypes++class WrapReturn a b where+ wrapReturn :: a -> IO b+instance WrapReturn a a where+ wrapReturn = return+instance WrapReturn CInt Int where+ wrapReturn = return . fromIntegral+instance WrapReturn CDouble Double where+ wrapReturn = return . realToFrac+instance WrapReturn CLong Int where+ wrapReturn = return . fromIntegral++foreign import ccall unsafe "hs_read_bool" c_readBool+ :: Ptr CppBool' -> IO CInt+instance WrapReturn (ForeignPtr CppBool') Bool where+ wrapReturn boolPtr' = withForeignPtr boolPtr' $ \boolPtr -> do+ ret <- c_readBool boolPtr+ return $ case ret of 0 -> False+ _ -> True+ ++foreign import ccall unsafe "hs_string_length" c_stringLength+ :: Ptr StdString' -> IO CInt+foreign import ccall unsafe "hs_string_copy" c_stringCopy+ :: Ptr StdString' -> Ptr CChar -> IO ()+instance WrapReturn (ForeignPtr StdString') String where+ wrapReturn stdStr' = withForeignPtr stdStr' $ \stdStr -> do+ len <- fmap fromIntegral $ c_stringLength stdStr+ cstring <- mallocArray (len + 1)+ c_stringCopy stdStr cstring+ ret <- peekCString cstring+ free cstring+ return ret++wrapReturnVec ::+ Storable a =>+ (Ptr (CppVec a) -> IO CInt) ->+ (Ptr (CppVec a) -> Ptr a -> IO ()) ->+ (a -> IO b) ->+ ForeignPtr (CppVec a) -> IO (V.Vector b)+wrapReturnVec vecSize vecCopy cToHs vecPtr' = withForeignPtr vecPtr' $ \vecPtr -> do+ n <- fmap fromIntegral (vecSize vecPtr)+ arr <- mallocArray n+ vecCopy vecPtr arr+ ret <- peekArray n arr+ free arr+ fmap V.fromList (mapM cToHs ret)++foreign import ccall unsafe "hs_vec_size_int" c_vecSizeCInt+ :: Ptr (CppVec CInt) -> IO CInt+foreign import ccall unsafe "hs_vec_copy_int" c_vecCopyCInt+ :: Ptr (CppVec CInt) -> Ptr CInt -> IO ()+foreign import ccall unsafe "hs_vec_size_double" c_vecSizeCDouble+ :: Ptr (CppVec CDouble) -> IO CInt+foreign import ccall unsafe "hs_vec_copy_double" c_vecCopyCDouble+ :: Ptr (CppVec CDouble) -> Ptr CDouble -> IO ()++instance WrapReturn (ForeignPtr (CppVec CInt)) (V.Vector Int) where+ wrapReturn = wrapReturnVec c_vecSizeCInt c_vecCopyCInt (return . fromIntegral)++instance WrapReturn (ForeignPtr (CppVec CDouble)) (V.Vector Double) where+ wrapReturn = wrapReturnVec c_vecSizeCDouble c_vecCopyCDouble (return . realToFrac)++foreign import ccall unsafe "hs_vec_size_voidp" c_vecSizeVoidP+ :: Ptr (CppVec (Ptr a)) -> IO CInt+foreign import ccall unsafe "hs_vec_copy_voidp" c_vecCopyVoidP+ :: Ptr (CppVec (Ptr a)) -> Ptr (Ptr a) -> IO ()+instance WrapReturn (ForeignPtr a) b =>+ WrapReturn (ForeignPtr (CppVec (Ptr a))) (V.Vector b) where+ wrapReturn = wrapReturnVec c_vecSizeVoidP c_vecCopyVoidP ((>>= wrapReturn) . newForeignPtr_)++wrapReturnVecVec+ :: Storable a =>+ (Ptr (CppVecVec a) -> IO CInt) ->+ (Ptr (CppVecVec a) -> Ptr CInt -> IO ()) ->+ (Ptr (CppVecVec a) -> Ptr (Ptr a) -> IO ()) ->+ (a -> IO b) ->+ (ForeignPtr (CppVecVec a)) -> IO (V.Vector (V.Vector b))+wrapReturnVecVec vecVecSize vecVecSizes vecVecCopy cToHs foreignVecPtr = withForeignPtr foreignVecPtr $ \vecPtr -> do+ outerLength <- fmap fromIntegral $ vecVecSize vecPtr+ innerLengthArray <- mallocArray outerLength+ vecVecSizes vecPtr innerLengthArray+ innerLengths <- fmap (map fromIntegral) $ peekArray outerLength innerLengthArray+ free innerLengthArray++ outputs <- mapM mallocArray innerLengths+ withArray outputs $ \outputArray ->+ vecVecCopy vecPtr outputArray+ outputLists <- zipWithM peekArray innerLengths outputs+ mapM_ free outputs+ let f = fmap V.fromList . mapM cToHs+ fmap V.fromList $ mapM f outputLists++foreign import ccall unsafe "hs_vec_vec_size_voidp" c_vecVecSizeVoidP+ :: Ptr (CppVecVec (Ptr a)) -> IO CInt+foreign import ccall unsafe "hs_vec_vec_sizes_voidp" c_vecVecSizesVoidP+ :: Ptr (CppVecVec (Ptr a)) -> Ptr CInt -> IO ()+foreign import ccall unsafe "hs_vec_vec_copy_voidp" c_vecVecCopyVoidP+ :: Ptr (CppVecVec (Ptr a)) -> Ptr (Ptr (Ptr a)) -> IO ()++instance WrapReturn (ForeignPtr a) b => WrapReturn (ForeignPtr (CppVecVec (Ptr a))) (V.Vector (V.Vector b)) where+ wrapReturn =+ wrapReturnVecVec c_vecVecSizeVoidP c_vecVecSizesVoidP c_vecVecCopyVoidP+ ((>>= wrapReturn) . newForeignPtr_)++foreign import ccall unsafe "hs_vec_vec_size_int" c_vecVecSizeInt+ :: Ptr (CppVecVec CInt) -> IO CInt+foreign import ccall unsafe "hs_vec_vec_sizes_int" c_vecVecSizesInt+ :: Ptr (CppVecVec CInt) -> Ptr CInt -> IO ()+foreign import ccall unsafe "hs_vec_vec_copy_int" c_vecVecCopyInt+ :: Ptr (CppVecVec CInt) -> Ptr (Ptr CInt) -> IO ()++instance WrapReturn (ForeignPtr (CppVecVec CInt)) (V.Vector (V.Vector Int)) where+ wrapReturn = wrapReturnVecVec c_vecVecSizeInt c_vecVecSizesInt c_vecVecCopyInt (return . fromIntegral)
+ Casadi/Wrappers/Classes/CRSSparsity.hs view
@@ -0,0 +1,728 @@+{-# OPTIONS_GHC -Wall #-}+{-# OPTIONS_GHC -fno-warn-unused-imports #-}+{-# OPTIONS_GHC -fno-warn-orphans #-}+{-# Language ForeignFunctionInterface #-}+{-# Language FlexibleInstances #-}+{-# Language MultiParamTypeClasses #-}++module Casadi.Wrappers.Classes.CRSSparsity+ (+ CRSSparsity,+ CRSSparsityClass(..),+ crsSparsity,+ crsSparsity',+ crsSparsity_col,+ crsSparsity_colRef,+ crsSparsity_columnsSequential,+ crsSparsity_dimString,+ crsSparsity_empty,+ crsSparsity_getElements,+ crsSparsity_getNZ,+ crsSparsity_getNZ'',+ crsSparsity_getNZInplace,+ crsSparsity_getRow,+ crsSparsity_hasNZ,+ crsSparsity_hash,+ crsSparsity_null,+ crsSparsity_numel,+ crsSparsity_rowind,+ crsSparsity_rowindRef,+ crsSparsity_size,+ crsSparsity_size1,+ crsSparsity_size2,+ crsSparsity_sizeD,+ crsSparsity_sizeL,+ crsSparsity_sizeU,+ crsSparsity_spy',+ crsSparsity_spyMatlab,+ crsSparsity_starColoring,+ crsSparsity_starColoring',+ crsSparsity_starColoring'',+ crsSparsity_starColoring2,+ crsSparsity_starColoring2',+ crsSparsity_starColoring2'',+ crsSparsity_unidirectionalColoring,+ crsSparsity_unidirectionalColoring',+ crsSparsity_unidirectionalColoring'',+ ) where+++import Prelude hiding ( Functor )++import Data.Vector ( Vector )+import Foreign.C.Types+import Foreign.Ptr ( Ptr )+import Foreign.ForeignPtr ( newForeignPtr )+import System.IO.Unsafe ( unsafePerformIO ) -- for show instances++import Casadi.Wrappers.Classes.PrintableObject+import Casadi.Wrappers.ForeignToolsInstances ( )+import Casadi.Wrappers.Deleters+import Casadi.Wrappers.Data+import Casadi.Wrappers.Enums+import Casadi.MarshalTypes ( CppVec, CppVecVec, CppVecVecVec,+ StdString', CppBool' ) -- StdOstream'+import Casadi.Marshal ( CornerCase(..), Marshal(..) )+import Casadi.WrapReturn ( WrapReturn(..) )++instance Show CRSSparsity where+ show = unsafePerformIO . printableObject_getDescription+-- direct wrapper+foreign import ccall unsafe "CasADi__CRSSparsity__size1" c_CasADi__CRSSparsity__size1+ :: Ptr CRSSparsity' -> IO CInt+casADi__CRSSparsity__size1+ :: CRSSparsity -> IO Int+casADi__CRSSparsity__size1 x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__CRSSparsity__size1 x0' >>= wrapReturn++-- classy wrapper+{-|+>Get the number of rows.+-}+crsSparsity_size1 :: CRSSparsityClass a => a -> IO Int+crsSparsity_size1 x = casADi__CRSSparsity__size1 (castCRSSparsity x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__CRSSparsity__size2" c_CasADi__CRSSparsity__size2+ :: Ptr CRSSparsity' -> IO CInt+casADi__CRSSparsity__size2+ :: CRSSparsity -> IO Int+casADi__CRSSparsity__size2 x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__CRSSparsity__size2 x0' >>= wrapReturn++-- classy wrapper+{-|+>Get the number of columns.+-}+crsSparsity_size2 :: CRSSparsityClass a => a -> IO Int+crsSparsity_size2 x = casADi__CRSSparsity__size2 (castCRSSparsity x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__CRSSparsity__numel" c_CasADi__CRSSparsity__numel+ :: Ptr CRSSparsity' -> IO CInt+casADi__CRSSparsity__numel+ :: CRSSparsity -> IO Int+casADi__CRSSparsity__numel x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__CRSSparsity__numel x0' >>= wrapReturn++-- classy wrapper+{-|+>The total number of elements, including structural zeros, i.e.+>size1()*size2()+>+>See: size()+-}+crsSparsity_numel :: CRSSparsityClass a => a -> IO Int+crsSparsity_numel x = casADi__CRSSparsity__numel (castCRSSparsity x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__CRSSparsity__empty" c_CasADi__CRSSparsity__empty+ :: Ptr CRSSparsity' -> IO (Ptr CppBool')+casADi__CRSSparsity__empty+ :: CRSSparsity -> IO Bool+casADi__CRSSparsity__empty x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__CRSSparsity__empty x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++-- classy wrapper+{-|+>Check if the sparsity is empty, i.e. one of its dimensions is 0.+-}+crsSparsity_empty :: CRSSparsityClass a => a -> IO Bool+crsSparsity_empty x = casADi__CRSSparsity__empty (castCRSSparsity x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__CRSSparsity__null" c_CasADi__CRSSparsity__null+ :: Ptr CRSSparsity' -> IO (Ptr CppBool')+casADi__CRSSparsity__null+ :: CRSSparsity -> IO Bool+casADi__CRSSparsity__null x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__CRSSparsity__null x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++-- classy wrapper+{-|+>Check if the sparsity is null, i.e. dimension is 0-by-0.+-}+crsSparsity_null :: CRSSparsityClass a => a -> IO Bool+crsSparsity_null x = casADi__CRSSparsity__null (castCRSSparsity x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__CRSSparsity__size" c_CasADi__CRSSparsity__size+ :: Ptr CRSSparsity' -> IO CInt+casADi__CRSSparsity__size+ :: CRSSparsity -> IO Int+casADi__CRSSparsity__size x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__CRSSparsity__size x0' >>= wrapReturn++-- classy wrapper+{-|+>Get the number of (structural) non-zeros.+>+>See: numel()+-}+crsSparsity_size :: CRSSparsityClass a => a -> IO Int+crsSparsity_size x = casADi__CRSSparsity__size (castCRSSparsity x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__CRSSparsity__sizeU" c_CasADi__CRSSparsity__sizeU+ :: Ptr CRSSparsity' -> IO CInt+casADi__CRSSparsity__sizeU+ :: CRSSparsity -> IO Int+casADi__CRSSparsity__sizeU x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__CRSSparsity__sizeU x0' >>= wrapReturn++-- classy wrapper+{-|+>Number of non-zeros in the upper triangular half, i.e. the number of+>elements (i,j) with j>=i.+-}+crsSparsity_sizeU :: CRSSparsityClass a => a -> IO Int+crsSparsity_sizeU x = casADi__CRSSparsity__sizeU (castCRSSparsity x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__CRSSparsity__sizeL" c_CasADi__CRSSparsity__sizeL+ :: Ptr CRSSparsity' -> IO CInt+casADi__CRSSparsity__sizeL+ :: CRSSparsity -> IO Int+casADi__CRSSparsity__sizeL x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__CRSSparsity__sizeL x0' >>= wrapReturn++-- classy wrapper+{-|+>Number of non-zeros in the lower triangular half, i.e. the number of+>elements (i,j) with j<=i.+-}+crsSparsity_sizeL :: CRSSparsityClass a => a -> IO Int+crsSparsity_sizeL x = casADi__CRSSparsity__sizeL (castCRSSparsity x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__CRSSparsity__sizeD" c_CasADi__CRSSparsity__sizeD+ :: Ptr CRSSparsity' -> IO CInt+casADi__CRSSparsity__sizeD+ :: CRSSparsity -> IO Int+casADi__CRSSparsity__sizeD x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__CRSSparsity__sizeD x0' >>= wrapReturn++-- classy wrapper+{-|+>Number of non-zeros on the diagonal, i.e. the number of elements (i,j) with+>j==i.+-}+crsSparsity_sizeD :: CRSSparsityClass a => a -> IO Int+crsSparsity_sizeD x = casADi__CRSSparsity__sizeD (castCRSSparsity x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__CRSSparsity__col" c_CasADi__CRSSparsity__col+ :: Ptr CRSSparsity' -> CInt -> IO CInt+casADi__CRSSparsity__col+ :: CRSSparsity -> Int -> IO Int+casADi__CRSSparsity__col x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__CRSSparsity__col x0' x1' >>= wrapReturn++-- classy wrapper+{-|+>> const vector< int > & CasADi::CRSSparsity::col() const +>------------------------------------------------------------------------+>+>Get a reference to col-vector, containing columns for all non-zero elements+>(see class description)+>+>> int CasADi::CRSSparsity::col(int el) const +>------------------------------------------------------------------------+>+>Get the column of a non-zero element.+-}+crsSparsity_col :: CRSSparsityClass a => a -> Int -> IO Int+crsSparsity_col x = casADi__CRSSparsity__col (castCRSSparsity x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__CRSSparsity__rowind" c_CasADi__CRSSparsity__rowind+ :: Ptr CRSSparsity' -> CInt -> IO CInt+casADi__CRSSparsity__rowind+ :: CRSSparsity -> Int -> IO Int+casADi__CRSSparsity__rowind x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__CRSSparsity__rowind x0' x1' >>= wrapReturn++-- classy wrapper+{-|+>> const vector< int > & CasADi::CRSSparsity::rowind() const +>------------------------------------------------------------------------+>+>Get a reference to the rowindex of all row element (see class description)+>+>> int CasADi::CRSSparsity::rowind(int i) const +>------------------------------------------------------------------------+>+>Get a reference to the rowindex of row i (see class description)+-}+crsSparsity_rowind :: CRSSparsityClass a => a -> Int -> IO Int+crsSparsity_rowind x = casADi__CRSSparsity__rowind (castCRSSparsity x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__CRSSparsity__colRef" c_CasADi__CRSSparsity__colRef+ :: Ptr CRSSparsity' -> IO (Ptr (CppVec CInt))+casADi__CRSSparsity__colRef+ :: CRSSparsity -> IO (Vector Int)+casADi__CRSSparsity__colRef x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__CRSSparsity__colRef x0' >>= (newForeignPtr c_delete_std__vector_int_) >>= wrapReturn++-- classy wrapper+{-|+>Get a reference to the columns of all non-zero element (copy if not unique!)+-}+crsSparsity_colRef :: CRSSparsityClass a => a -> IO (Vector Int)+crsSparsity_colRef x = casADi__CRSSparsity__colRef (castCRSSparsity x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__CRSSparsity__rowindRef" c_CasADi__CRSSparsity__rowindRef+ :: Ptr CRSSparsity' -> IO (Ptr (CppVec CInt))+casADi__CRSSparsity__rowindRef+ :: CRSSparsity -> IO (Vector Int)+casADi__CRSSparsity__rowindRef x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__CRSSparsity__rowindRef x0' >>= (newForeignPtr c_delete_std__vector_int_) >>= wrapReturn++-- classy wrapper+{-|+>Get a reference to the rowindex of all row element (copy if not unique!)+-}+crsSparsity_rowindRef :: CRSSparsityClass a => a -> IO (Vector Int)+crsSparsity_rowindRef x = casADi__CRSSparsity__rowindRef (castCRSSparsity x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__CRSSparsity__getRow" c_CasADi__CRSSparsity__getRow+ :: Ptr CRSSparsity' -> IO (Ptr (CppVec CInt))+casADi__CRSSparsity__getRow+ :: CRSSparsity -> IO (Vector Int)+casADi__CRSSparsity__getRow x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__CRSSparsity__getRow x0' >>= (newForeignPtr c_delete_std__vector_int_) >>= wrapReturn++-- classy wrapper+{-|+>Get the row for each non-zero entry Together with the col-vector, this+>vector gives the sparsity of the matrix in sparse triplet format, i.e. the+>row and column for each non-zero elements.+-}+crsSparsity_getRow :: CRSSparsityClass a => a -> IO (Vector Int)+crsSparsity_getRow x = casADi__CRSSparsity__getRow (castCRSSparsity x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__CRSSparsity__getNZ" c_CasADi__CRSSparsity__getNZ+ :: Ptr CRSSparsity' -> CInt -> CInt -> IO CInt+casADi__CRSSparsity__getNZ+ :: CRSSparsity -> Int -> Int -> IO Int+casADi__CRSSparsity__getNZ x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__CRSSparsity__getNZ x0' x1' x2' >>= wrapReturn++-- classy wrapper+{-|+>> int CasADi::CRSSparsity::getNZ(int i, int j)+>------------------------------------------------------------------------+>+>Get the index of a non-zero element Add the element if it does not exist and+>copy object if it's not unique.+>+>> int CasADi::CRSSparsity::getNZ(int i, int j) const +>------------------------------------------------------------------------+>+>Get the index of an existing non-zero element return -1 if the element does+>not exists.+>+>> std::vector<int> CasADi::CRSSparsity::getNZ(const std::vector< int > &ii, const std::vector< int > &jj) const +>------------------------------------------------------------------------+>+>Get a set of non-zero element return -1 if the element does not exists.+-}+crsSparsity_getNZ :: CRSSparsityClass a => a -> Int -> Int -> IO Int+crsSparsity_getNZ x = casADi__CRSSparsity__getNZ (castCRSSparsity x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__CRSSparsity__getNZ_TIC_TIC" c_CasADi__CRSSparsity__getNZ_TIC_TIC+ :: Ptr CRSSparsity' -> Ptr (CppVec CInt) -> Ptr (CppVec CInt) -> IO (Ptr (CppVec CInt))+casADi__CRSSparsity__getNZ''+ :: CRSSparsity -> Vector Int -> Vector Int -> IO (Vector Int)+casADi__CRSSparsity__getNZ'' x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__CRSSparsity__getNZ_TIC_TIC x0' x1' x2' >>= (newForeignPtr c_delete_std__vector_int_) >>= wrapReturn++-- classy wrapper+crsSparsity_getNZ'' :: CRSSparsityClass a => a -> Vector Int -> Vector Int -> IO (Vector Int)+crsSparsity_getNZ'' x = casADi__CRSSparsity__getNZ'' (castCRSSparsity x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__CRSSparsity__hasNZ" c_CasADi__CRSSparsity__hasNZ+ :: Ptr CRSSparsity' -> CInt -> CInt -> IO (Ptr CppBool')+casADi__CRSSparsity__hasNZ+ :: CRSSparsity -> Int -> Int -> IO Bool+casADi__CRSSparsity__hasNZ x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__CRSSparsity__hasNZ x0' x1' x2' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++-- classy wrapper+{-|+>Returns true if the pattern has a non-zero at location i,j.+-}+crsSparsity_hasNZ :: CRSSparsityClass a => a -> Int -> Int -> IO Bool+crsSparsity_hasNZ x = casADi__CRSSparsity__hasNZ (castCRSSparsity x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__CRSSparsity__getNZInplace" c_CasADi__CRSSparsity__getNZInplace+ :: Ptr CRSSparsity' -> Ptr (CppVec CInt) -> IO ()+casADi__CRSSparsity__getNZInplace+ :: CRSSparsity -> Vector Int -> IO ()+casADi__CRSSparsity__getNZInplace x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__CRSSparsity__getNZInplace x0' x1' >>= wrapReturn++-- classy wrapper+{-|+>Get the nonzero index for a set of elements The index vector is used both+>for input and outputs and must be sorted by increasing nonzero index, i.e.+>row-wise. Elements not found in the sparsity pattern are set to -1.+-}+crsSparsity_getNZInplace :: CRSSparsityClass a => a -> Vector Int -> IO ()+crsSparsity_getNZInplace x = casADi__CRSSparsity__getNZInplace (castCRSSparsity x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__CRSSparsity__columnsSequential" c_CasADi__CRSSparsity__columnsSequential+ :: Ptr CRSSparsity' -> Ptr CppBool' -> IO (Ptr CppBool')+casADi__CRSSparsity__columnsSequential+ :: CRSSparsity -> Bool -> IO Bool+casADi__CRSSparsity__columnsSequential x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__CRSSparsity__columnsSequential x0' x1' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++-- classy wrapper+{-|+>Does the columns appear sequentially on each row (if strictly==true, then do+>not allow multiple entries)+-}+crsSparsity_columnsSequential :: CRSSparsityClass a => a -> Bool -> IO Bool+crsSparsity_columnsSequential x = casADi__CRSSparsity__columnsSequential (castCRSSparsity x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__CRSSparsity__getElements" c_CasADi__CRSSparsity__getElements+ :: Ptr CRSSparsity' -> Ptr CppBool' -> IO (Ptr (CppVec CInt))+casADi__CRSSparsity__getElements+ :: CRSSparsity -> Bool -> IO (Vector Int)+casADi__CRSSparsity__getElements x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__CRSSparsity__getElements x0' x1' >>= (newForeignPtr c_delete_std__vector_int_) >>= wrapReturn++-- classy wrapper+{-|+>> std::vector< int > CasADi::CRSSparsity::getElements(bool row_major=true) const +>------------------------------------------------------------------------+>+>Get the location of all nonzero elements.+>+>> void CasADi::CRSSparsity::getElements(std::vector< int > &loc, bool row_major=true) const +>------------------------------------------------------------------------+>+>Get the location of all nonzero elements (inplace version)+-}+crsSparsity_getElements :: CRSSparsityClass a => a -> Bool -> IO (Vector Int)+crsSparsity_getElements x = casADi__CRSSparsity__getElements (castCRSSparsity x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__CRSSparsity__unidirectionalColoring" c_CasADi__CRSSparsity__unidirectionalColoring+ :: Ptr CRSSparsity' -> Ptr CRSSparsity' -> CInt -> IO (Ptr CRSSparsity')+casADi__CRSSparsity__unidirectionalColoring+ :: CRSSparsity -> CRSSparsity -> Int -> IO CRSSparsity+casADi__CRSSparsity__unidirectionalColoring x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__CRSSparsity__unidirectionalColoring x0' x1' x2' >>= (newForeignPtr c_delete_CasADi__CRSSparsity) >>= wrapReturn++-- classy wrapper+{-|+>Perform a unidirectional coloring: A greedy distance-2 coloring algorithm+>(Algorithm 3.1 in A. H. GEBREMEDHIN, F. MANNE, A. POTHEN)+-}+crsSparsity_unidirectionalColoring :: CRSSparsityClass a => a -> CRSSparsity -> Int -> IO CRSSparsity+crsSparsity_unidirectionalColoring x = casADi__CRSSparsity__unidirectionalColoring (castCRSSparsity x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__CRSSparsity__unidirectionalColoring_TIC" c_CasADi__CRSSparsity__unidirectionalColoring_TIC+ :: Ptr CRSSparsity' -> Ptr CRSSparsity' -> IO (Ptr CRSSparsity')+casADi__CRSSparsity__unidirectionalColoring'+ :: CRSSparsity -> CRSSparsity -> IO CRSSparsity+casADi__CRSSparsity__unidirectionalColoring' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__CRSSparsity__unidirectionalColoring_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__CRSSparsity) >>= wrapReturn++-- classy wrapper+crsSparsity_unidirectionalColoring' :: CRSSparsityClass a => a -> CRSSparsity -> IO CRSSparsity+crsSparsity_unidirectionalColoring' x = casADi__CRSSparsity__unidirectionalColoring' (castCRSSparsity x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__CRSSparsity__unidirectionalColoring_TIC_TIC" c_CasADi__CRSSparsity__unidirectionalColoring_TIC_TIC+ :: Ptr CRSSparsity' -> IO (Ptr CRSSparsity')+casADi__CRSSparsity__unidirectionalColoring''+ :: CRSSparsity -> IO CRSSparsity+casADi__CRSSparsity__unidirectionalColoring'' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__CRSSparsity__unidirectionalColoring_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__CRSSparsity) >>= wrapReturn++-- classy wrapper+crsSparsity_unidirectionalColoring'' :: CRSSparsityClass a => a -> IO CRSSparsity+crsSparsity_unidirectionalColoring'' x = casADi__CRSSparsity__unidirectionalColoring'' (castCRSSparsity x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__CRSSparsity__starColoring" c_CasADi__CRSSparsity__starColoring+ :: Ptr CRSSparsity' -> CInt -> CInt -> IO (Ptr CRSSparsity')+casADi__CRSSparsity__starColoring+ :: CRSSparsity -> Int -> Int -> IO CRSSparsity+casADi__CRSSparsity__starColoring x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__CRSSparsity__starColoring x0' x1' x2' >>= (newForeignPtr c_delete_CasADi__CRSSparsity) >>= wrapReturn++-- classy wrapper+{-|+>Perform a star coloring of a symmetric matrix: A greedy distance-2 coloring+>algorithm (Algorithm 4.1 in A. H. GEBREMEDHIN, F. MANNE, A. POTHEN) Ordering+>options: None (0), largest first (1)+-}+crsSparsity_starColoring :: CRSSparsityClass a => a -> Int -> Int -> IO CRSSparsity+crsSparsity_starColoring x = casADi__CRSSparsity__starColoring (castCRSSparsity x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__CRSSparsity__starColoring_TIC" c_CasADi__CRSSparsity__starColoring_TIC+ :: Ptr CRSSparsity' -> CInt -> IO (Ptr CRSSparsity')+casADi__CRSSparsity__starColoring'+ :: CRSSparsity -> Int -> IO CRSSparsity+casADi__CRSSparsity__starColoring' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__CRSSparsity__starColoring_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__CRSSparsity) >>= wrapReturn++-- classy wrapper+crsSparsity_starColoring' :: CRSSparsityClass a => a -> Int -> IO CRSSparsity+crsSparsity_starColoring' x = casADi__CRSSparsity__starColoring' (castCRSSparsity x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__CRSSparsity__starColoring_TIC_TIC" c_CasADi__CRSSparsity__starColoring_TIC_TIC+ :: Ptr CRSSparsity' -> IO (Ptr CRSSparsity')+casADi__CRSSparsity__starColoring''+ :: CRSSparsity -> IO CRSSparsity+casADi__CRSSparsity__starColoring'' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__CRSSparsity__starColoring_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__CRSSparsity) >>= wrapReturn++-- classy wrapper+crsSparsity_starColoring'' :: CRSSparsityClass a => a -> IO CRSSparsity+crsSparsity_starColoring'' x = casADi__CRSSparsity__starColoring'' (castCRSSparsity x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__CRSSparsity__starColoring2" c_CasADi__CRSSparsity__starColoring2+ :: Ptr CRSSparsity' -> CInt -> CInt -> IO (Ptr CRSSparsity')+casADi__CRSSparsity__starColoring2+ :: CRSSparsity -> Int -> Int -> IO CRSSparsity+casADi__CRSSparsity__starColoring2 x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__CRSSparsity__starColoring2 x0' x1' x2' >>= (newForeignPtr c_delete_CasADi__CRSSparsity) >>= wrapReturn++-- classy wrapper+{-|+>Perform a star coloring of a symmetric matrix: A new greedy distance-2+>coloring algorithm (Algorithm 4.1 in A. H. GEBREMEDHIN, A. TARAFDAR, F.+>MANNE, A. POTHEN) Ordering options: None (0), largest first (1)+-}+crsSparsity_starColoring2 :: CRSSparsityClass a => a -> Int -> Int -> IO CRSSparsity+crsSparsity_starColoring2 x = casADi__CRSSparsity__starColoring2 (castCRSSparsity x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__CRSSparsity__starColoring2_TIC" c_CasADi__CRSSparsity__starColoring2_TIC+ :: Ptr CRSSparsity' -> CInt -> IO (Ptr CRSSparsity')+casADi__CRSSparsity__starColoring2'+ :: CRSSparsity -> Int -> IO CRSSparsity+casADi__CRSSparsity__starColoring2' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__CRSSparsity__starColoring2_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__CRSSparsity) >>= wrapReturn++-- classy wrapper+crsSparsity_starColoring2' :: CRSSparsityClass a => a -> Int -> IO CRSSparsity+crsSparsity_starColoring2' x = casADi__CRSSparsity__starColoring2' (castCRSSparsity x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__CRSSparsity__starColoring2_TIC_TIC" c_CasADi__CRSSparsity__starColoring2_TIC_TIC+ :: Ptr CRSSparsity' -> IO (Ptr CRSSparsity')+casADi__CRSSparsity__starColoring2''+ :: CRSSparsity -> IO CRSSparsity+casADi__CRSSparsity__starColoring2'' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__CRSSparsity__starColoring2_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__CRSSparsity) >>= wrapReturn++-- classy wrapper+crsSparsity_starColoring2'' :: CRSSparsityClass a => a -> IO CRSSparsity+crsSparsity_starColoring2'' x = casADi__CRSSparsity__starColoring2'' (castCRSSparsity x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__CRSSparsity__dimString" c_CasADi__CRSSparsity__dimString+ :: Ptr CRSSparsity' -> IO (Ptr StdString')+casADi__CRSSparsity__dimString+ :: CRSSparsity -> IO String+casADi__CRSSparsity__dimString x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__CRSSparsity__dimString x0' >>= (newForeignPtr c_delete_std__string) >>= wrapReturn++-- classy wrapper+{-|+>Get the dimension as a string.+-}+crsSparsity_dimString :: CRSSparsityClass a => a -> IO String+crsSparsity_dimString x = casADi__CRSSparsity__dimString (castCRSSparsity x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__CRSSparsity__spy_TIC" c_CasADi__CRSSparsity__spy_TIC+ :: Ptr CRSSparsity' -> IO ()+casADi__CRSSparsity__spy'+ :: CRSSparsity -> IO ()+casADi__CRSSparsity__spy' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__CRSSparsity__spy_TIC x0' >>= wrapReturn++-- classy wrapper+crsSparsity_spy' :: CRSSparsityClass a => a -> IO ()+crsSparsity_spy' x = casADi__CRSSparsity__spy' (castCRSSparsity x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__CRSSparsity__spyMatlab" c_CasADi__CRSSparsity__spyMatlab+ :: Ptr CRSSparsity' -> Ptr StdString' -> IO ()+casADi__CRSSparsity__spyMatlab+ :: CRSSparsity -> String -> IO ()+casADi__CRSSparsity__spyMatlab x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__CRSSparsity__spyMatlab x0' x1' >>= wrapReturn++-- classy wrapper+{-|+>Generate a script for Matlab or Octave which visualizes the sparsity using+>the spy command.+-}+crsSparsity_spyMatlab :: CRSSparsityClass a => a -> String -> IO ()+crsSparsity_spyMatlab x = casADi__CRSSparsity__spyMatlab (castCRSSparsity x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__CRSSparsity__hash" c_CasADi__CRSSparsity__hash+ :: Ptr CRSSparsity' -> IO CSize+casADi__CRSSparsity__hash+ :: CRSSparsity -> IO CSize+casADi__CRSSparsity__hash x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__CRSSparsity__hash x0' >>= wrapReturn++-- classy wrapper+crsSparsity_hash :: CRSSparsityClass a => a -> IO CSize+crsSparsity_hash x = casADi__CRSSparsity__hash (castCRSSparsity x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__CRSSparsity__CRSSparsity" c_CasADi__CRSSparsity__CRSSparsity+ :: CInt -> CInt -> Ptr (CppVec CInt) -> Ptr (CppVec CInt) -> IO (Ptr CRSSparsity')+casADi__CRSSparsity__CRSSparsity+ :: Int -> Int -> Vector Int -> Vector Int -> IO CRSSparsity+casADi__CRSSparsity__CRSSparsity x0 x1 x2 x3 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ withMarshal x3 $ \x3' ->+ c_CasADi__CRSSparsity__CRSSparsity x0' x1' x2' x3' >>= (newForeignPtr c_delete_CasADi__CRSSparsity) >>= wrapReturn++-- classy wrapper+{-|+>> CasADi::CRSSparsity::CRSSparsity(int dummy=0)+>------------------------------------------------------------------------+>+>Default constructor.+>+>> CasADi::CRSSparsity::CRSSparsity(int nrow, int ncol, bool dense=false)+>------------------------------------------------------------------------+>+>Construct a sparsity pattern (sparse/dense)+>+>> CasADi::CRSSparsity::CRSSparsity(int nrow, int ncol, const std::vector< int > &col, const std::vector< int > &rowind)+>------------------------------------------------------------------------+>+>Construct a sparsity pattern from vectors.+-}+crsSparsity :: Int -> Int -> Vector Int -> Vector Int -> IO CRSSparsity+crsSparsity = casADi__CRSSparsity__CRSSparsity+++-- direct wrapper+foreign import ccall unsafe "CasADi__CRSSparsity__CRSSparsity_TIC" c_CasADi__CRSSparsity__CRSSparsity_TIC+ :: IO (Ptr CRSSparsity')+casADi__CRSSparsity__CRSSparsity'+ :: IO CRSSparsity+casADi__CRSSparsity__CRSSparsity' =+ c_CasADi__CRSSparsity__CRSSparsity_TIC >>= (newForeignPtr c_delete_CasADi__CRSSparsity) >>= wrapReturn++-- classy wrapper+crsSparsity' :: IO CRSSparsity+crsSparsity' = casADi__CRSSparsity__CRSSparsity'+
+ Casadi/Wrappers/Classes/CSparse.hs view
@@ -0,0 +1,107 @@+{-# OPTIONS_GHC -Wall #-}+{-# OPTIONS_GHC -fno-warn-unused-imports #-}+{-# OPTIONS_GHC -fno-warn-orphans #-}+{-# Language ForeignFunctionInterface #-}+{-# Language FlexibleInstances #-}+{-# Language MultiParamTypeClasses #-}++module Casadi.Wrappers.Classes.CSparse+ (+ CSparse,+ CSparseClass(..),+ csparse,+ csparse',+ csparse'',+ csparse_checkNode,+ ) where+++import Prelude hiding ( Functor )++import Data.Vector ( Vector )+import Foreign.C.Types+import Foreign.Ptr ( Ptr )+import Foreign.ForeignPtr ( newForeignPtr )+import System.IO.Unsafe ( unsafePerformIO ) -- for show instances++import Casadi.Wrappers.Classes.PrintableObject+import Casadi.Wrappers.ForeignToolsInstances ( )+import Casadi.Wrappers.Deleters+import Casadi.Wrappers.Data+import Casadi.Wrappers.Enums+import Casadi.MarshalTypes ( CppVec, CppVecVec, CppVecVecVec,+ StdString', CppBool' ) -- StdOstream'+import Casadi.Marshal ( CornerCase(..), Marshal(..) )+import Casadi.WrapReturn ( WrapReturn(..) )++instance Show CSparse where+ show = unsafePerformIO . printableObject_getDescription+-- direct wrapper+foreign import ccall unsafe "CasADi__CSparse__checkNode" c_CasADi__CSparse__checkNode+ :: Ptr CSparse' -> IO (Ptr CppBool')+casADi__CSparse__checkNode+ :: CSparse -> IO Bool+casADi__CSparse__checkNode x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__CSparse__checkNode x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++-- classy wrapper+{-|+>Check if the node is pointing to the right type of object.+-}+csparse_checkNode :: CSparseClass a => a -> IO Bool+csparse_checkNode x = casADi__CSparse__checkNode (castCSparse x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__CSparse__CSparse" c_CasADi__CSparse__CSparse+ :: IO (Ptr CSparse')+casADi__CSparse__CSparse+ :: IO CSparse+casADi__CSparse__CSparse =+ c_CasADi__CSparse__CSparse >>= (newForeignPtr c_delete_CasADi__CSparse) >>= wrapReturn++-- classy wrapper+{-|+>> CasADi::CSparse::CSparse()+>------------------------------------------------------------------------+>+>Default (empty) constructor.+>+>> CasADi::CSparse::CSparse(const CRSSparsity &sp, int nrhs=1)+>------------------------------------------------------------------------+>+>Create a linear solver given a sparsity pattern.+-}+csparse :: IO CSparse+csparse = casADi__CSparse__CSparse+++-- direct wrapper+foreign import ccall unsafe "CasADi__CSparse__CSparse_TIC" c_CasADi__CSparse__CSparse_TIC+ :: Ptr CRSSparsity' -> CInt -> IO (Ptr CSparse')+casADi__CSparse__CSparse'+ :: CRSSparsity -> Int -> IO CSparse+casADi__CSparse__CSparse' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__CSparse__CSparse_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__CSparse) >>= wrapReturn++-- classy wrapper+csparse' :: CRSSparsity -> Int -> IO CSparse+csparse' = casADi__CSparse__CSparse'+++-- direct wrapper+foreign import ccall unsafe "CasADi__CSparse__CSparse_TIC_TIC" c_CasADi__CSparse__CSparse_TIC_TIC+ :: Ptr CRSSparsity' -> IO (Ptr CSparse')+casADi__CSparse__CSparse''+ :: CRSSparsity -> IO CSparse+casADi__CSparse__CSparse'' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__CSparse__CSparse_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__CSparse) >>= wrapReturn++-- classy wrapper+csparse'' :: CRSSparsity -> IO CSparse+csparse'' = casADi__CSparse__CSparse''+
+ Casadi/Wrappers/Classes/Callback.hs view
@@ -0,0 +1,58 @@+{-# OPTIONS_GHC -Wall #-}+{-# OPTIONS_GHC -fno-warn-unused-imports #-}+{-# OPTIONS_GHC -fno-warn-orphans #-}+{-# Language ForeignFunctionInterface #-}+{-# Language FlexibleInstances #-}+{-# Language MultiParamTypeClasses #-}++module Casadi.Wrappers.Classes.Callback+ (+ Callback,+ CallbackClass(..),+ callback,+ ) where+++import Prelude hiding ( Functor )++import Data.Vector ( Vector )+import Foreign.C.Types+import Foreign.Ptr ( Ptr )+import Foreign.ForeignPtr ( newForeignPtr )+import System.IO.Unsafe ( unsafePerformIO ) -- for show instances++import Casadi.Wrappers.Classes.PrintableObject+import Casadi.Wrappers.ForeignToolsInstances ( )+import Casadi.Wrappers.Deleters+import Casadi.Wrappers.Data+import Casadi.Wrappers.Enums+import Casadi.MarshalTypes ( CppVec, CppVecVec, CppVecVecVec,+ StdString', CppBool' ) -- StdOstream'+import Casadi.Marshal ( CornerCase(..), Marshal(..) )+import Casadi.WrapReturn ( WrapReturn(..) )++instance Show Callback where+ show = unsafePerformIO . printableObject_getDescription+-- direct wrapper+foreign import ccall unsafe "CasADi__Callback__Callback" c_CasADi__Callback__Callback+ :: IO (Ptr Callback')+casADi__Callback__Callback+ :: IO Callback+casADi__Callback__Callback =+ c_CasADi__Callback__Callback >>= (newForeignPtr c_delete_CasADi__Callback) >>= wrapReturn++-- classy wrapper+{-|+>> CasADi::Callback::Callback()+>------------------------------------------------------------------------+>+>Default constructor.+>+>> CasADi::Callback::Callback(CallbackCPtr ptr)+>------------------------------------------------------------------------+>+>Construct from C pointer.+-}+callback :: IO Callback+callback = casADi__Callback__Callback+
+ Casadi/Wrappers/Classes/CasadiMeta.hs view
@@ -0,0 +1,142 @@+{-# OPTIONS_GHC -Wall #-}+{-# OPTIONS_GHC -fno-warn-unused-imports #-}+{-# OPTIONS_GHC -fno-warn-orphans #-}+{-# Language ForeignFunctionInterface #-}+{-# Language FlexibleInstances #-}+{-# Language MultiParamTypeClasses #-}++module Casadi.Wrappers.Classes.CasadiMeta+ (+ CasadiMeta,+ CasadiMetaClass(..),+ casadiMeta_getBuildType,+ casadiMeta_getCompiler,+ casadiMeta_getCompilerFlags,+ casadiMeta_getCompilerId,+ casadiMeta_getFeatureList,+ casadiMeta_getGitDescribe,+ casadiMeta_getGitRevision,+ casadiMeta_getVersion,+ ) 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.ForeignToolsInstances ( )+import Casadi.Wrappers.Deleters+import Casadi.Wrappers.Data+import Casadi.Wrappers.Enums+import Casadi.MarshalTypes ( CppVec, CppVecVec, CppVecVecVec,+ StdString', CppBool' ) -- StdOstream'+import Casadi.Marshal ( CornerCase(..), Marshal(..) )+import Casadi.WrapReturn ( WrapReturn(..) )++-- direct wrapper+foreign import ccall unsafe "CasADi__CasadiMeta__getVersion" c_CasADi__CasadiMeta__getVersion+ :: IO (Ptr StdString')+casADi__CasadiMeta__getVersion+ :: IO String+casADi__CasadiMeta__getVersion =+ c_CasADi__CasadiMeta__getVersion >>= (newForeignPtr c_delete_std__string) >>= wrapReturn++-- classy wrapper+casadiMeta_getVersion :: IO String+casadiMeta_getVersion = casADi__CasadiMeta__getVersion+++-- direct wrapper+foreign import ccall unsafe "CasADi__CasadiMeta__getGitRevision" c_CasADi__CasadiMeta__getGitRevision+ :: IO (Ptr StdString')+casADi__CasadiMeta__getGitRevision+ :: IO String+casADi__CasadiMeta__getGitRevision =+ c_CasADi__CasadiMeta__getGitRevision >>= (newForeignPtr c_delete_std__string) >>= wrapReturn++-- classy wrapper+casadiMeta_getGitRevision :: IO String+casadiMeta_getGitRevision = casADi__CasadiMeta__getGitRevision+++-- direct wrapper+foreign import ccall unsafe "CasADi__CasadiMeta__getGitDescribe" c_CasADi__CasadiMeta__getGitDescribe+ :: IO (Ptr StdString')+casADi__CasadiMeta__getGitDescribe+ :: IO String+casADi__CasadiMeta__getGitDescribe =+ c_CasADi__CasadiMeta__getGitDescribe >>= (newForeignPtr c_delete_std__string) >>= wrapReturn++-- classy wrapper+casadiMeta_getGitDescribe :: IO String+casadiMeta_getGitDescribe = casADi__CasadiMeta__getGitDescribe+++-- direct wrapper+foreign import ccall unsafe "CasADi__CasadiMeta__getFeatureList" c_CasADi__CasadiMeta__getFeatureList+ :: IO (Ptr StdString')+casADi__CasadiMeta__getFeatureList+ :: IO String+casADi__CasadiMeta__getFeatureList =+ c_CasADi__CasadiMeta__getFeatureList >>= (newForeignPtr c_delete_std__string) >>= wrapReturn++-- classy wrapper+casadiMeta_getFeatureList :: IO String+casadiMeta_getFeatureList = casADi__CasadiMeta__getFeatureList+++-- direct wrapper+foreign import ccall unsafe "CasADi__CasadiMeta__getBuildType" c_CasADi__CasadiMeta__getBuildType+ :: IO (Ptr StdString')+casADi__CasadiMeta__getBuildType+ :: IO String+casADi__CasadiMeta__getBuildType =+ c_CasADi__CasadiMeta__getBuildType >>= (newForeignPtr c_delete_std__string) >>= wrapReturn++-- classy wrapper+casadiMeta_getBuildType :: IO String+casadiMeta_getBuildType = casADi__CasadiMeta__getBuildType+++-- direct wrapper+foreign import ccall unsafe "CasADi__CasadiMeta__getCompilerId" c_CasADi__CasadiMeta__getCompilerId+ :: IO (Ptr StdString')+casADi__CasadiMeta__getCompilerId+ :: IO String+casADi__CasadiMeta__getCompilerId =+ c_CasADi__CasadiMeta__getCompilerId >>= (newForeignPtr c_delete_std__string) >>= wrapReturn++-- classy wrapper+casadiMeta_getCompilerId :: IO String+casadiMeta_getCompilerId = casADi__CasadiMeta__getCompilerId+++-- direct wrapper+foreign import ccall unsafe "CasADi__CasadiMeta__getCompiler" c_CasADi__CasadiMeta__getCompiler+ :: IO (Ptr StdString')+casADi__CasadiMeta__getCompiler+ :: IO String+casADi__CasadiMeta__getCompiler =+ c_CasADi__CasadiMeta__getCompiler >>= (newForeignPtr c_delete_std__string) >>= wrapReturn++-- classy wrapper+casadiMeta_getCompiler :: IO String+casadiMeta_getCompiler = casADi__CasadiMeta__getCompiler+++-- direct wrapper+foreign import ccall unsafe "CasADi__CasadiMeta__getCompilerFlags" c_CasADi__CasadiMeta__getCompilerFlags+ :: IO (Ptr StdString')+casADi__CasadiMeta__getCompilerFlags+ :: IO String+casADi__CasadiMeta__getCompilerFlags =+ c_CasADi__CasadiMeta__getCompilerFlags >>= (newForeignPtr c_delete_std__string) >>= wrapReturn++-- classy wrapper+casadiMeta_getCompilerFlags :: IO String+casadiMeta_getCompilerFlags = casADi__CasadiMeta__getCompilerFlags+
+ Casadi/Wrappers/Classes/CasadiOptions.hs view
@@ -0,0 +1,117 @@+{-# OPTIONS_GHC -Wall #-}+{-# OPTIONS_GHC -fno-warn-unused-imports #-}+{-# OPTIONS_GHC -fno-warn-orphans #-}+{-# Language ForeignFunctionInterface #-}+{-# Language FlexibleInstances #-}+{-# Language MultiParamTypeClasses #-}++module Casadi.Wrappers.Classes.CasadiOptions+ (+ CasadiOptions,+ CasadiOptionsClass(..),+ casadiOptions_getCatchErrorsPython,+ casadiOptions_getSimplificationOnTheFly,+ casadiOptions_setCatchErrorsPython,+ casadiOptions_setSimplificationOnTheFly,+ casadiOptions_startProfiling,+ casadiOptions_stopProfiling,+ ) 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.ForeignToolsInstances ( )+import Casadi.Wrappers.Deleters+import Casadi.Wrappers.Data+import Casadi.Wrappers.Enums+import Casadi.MarshalTypes ( CppVec, CppVecVec, CppVecVecVec,+ StdString', CppBool' ) -- StdOstream'+import Casadi.Marshal ( CornerCase(..), Marshal(..) )+import Casadi.WrapReturn ( WrapReturn(..) )++-- direct wrapper+foreign import ccall unsafe "CasADi__CasadiOptions__setCatchErrorsPython" c_CasADi__CasadiOptions__setCatchErrorsPython+ :: Ptr CppBool' -> IO ()+casADi__CasadiOptions__setCatchErrorsPython+ :: Bool -> IO ()+casADi__CasadiOptions__setCatchErrorsPython x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__CasadiOptions__setCatchErrorsPython x0' >>= wrapReturn++-- classy wrapper+casadiOptions_setCatchErrorsPython :: Bool -> IO ()+casadiOptions_setCatchErrorsPython = casADi__CasadiOptions__setCatchErrorsPython+++-- direct wrapper+foreign import ccall unsafe "CasADi__CasadiOptions__getCatchErrorsPython" c_CasADi__CasadiOptions__getCatchErrorsPython+ :: IO (Ptr CppBool')+casADi__CasadiOptions__getCatchErrorsPython+ :: IO Bool+casADi__CasadiOptions__getCatchErrorsPython =+ c_CasADi__CasadiOptions__getCatchErrorsPython >>= (newForeignPtr c_delete_bool) >>= wrapReturn++-- classy wrapper+casadiOptions_getCatchErrorsPython :: IO Bool+casadiOptions_getCatchErrorsPython = casADi__CasadiOptions__getCatchErrorsPython+++-- direct wrapper+foreign import ccall unsafe "CasADi__CasadiOptions__setSimplificationOnTheFly" c_CasADi__CasadiOptions__setSimplificationOnTheFly+ :: Ptr CppBool' -> IO ()+casADi__CasadiOptions__setSimplificationOnTheFly+ :: Bool -> IO ()+casADi__CasadiOptions__setSimplificationOnTheFly x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__CasadiOptions__setSimplificationOnTheFly x0' >>= wrapReturn++-- classy wrapper+casadiOptions_setSimplificationOnTheFly :: Bool -> IO ()+casadiOptions_setSimplificationOnTheFly = casADi__CasadiOptions__setSimplificationOnTheFly+++-- direct wrapper+foreign import ccall unsafe "CasADi__CasadiOptions__getSimplificationOnTheFly" c_CasADi__CasadiOptions__getSimplificationOnTheFly+ :: IO (Ptr CppBool')+casADi__CasadiOptions__getSimplificationOnTheFly+ :: IO Bool+casADi__CasadiOptions__getSimplificationOnTheFly =+ c_CasADi__CasadiOptions__getSimplificationOnTheFly >>= (newForeignPtr c_delete_bool) >>= wrapReturn++-- classy wrapper+casadiOptions_getSimplificationOnTheFly :: IO Bool+casadiOptions_getSimplificationOnTheFly = casADi__CasadiOptions__getSimplificationOnTheFly+++-- direct wrapper+foreign import ccall unsafe "CasADi__CasadiOptions__startProfiling" c_CasADi__CasadiOptions__startProfiling+ :: Ptr StdString' -> IO ()+casADi__CasadiOptions__startProfiling+ :: String -> IO ()+casADi__CasadiOptions__startProfiling x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__CasadiOptions__startProfiling x0' >>= wrapReturn++-- classy wrapper+casadiOptions_startProfiling :: String -> IO ()+casadiOptions_startProfiling = casADi__CasadiOptions__startProfiling+++-- direct wrapper+foreign import ccall unsafe "CasADi__CasadiOptions__stopProfiling" c_CasADi__CasadiOptions__stopProfiling+ :: IO ()+casADi__CasadiOptions__stopProfiling+ :: IO ()+casADi__CasadiOptions__stopProfiling =+ c_CasADi__CasadiOptions__stopProfiling >>= wrapReturn++-- classy wrapper+casadiOptions_stopProfiling :: IO ()+casadiOptions_stopProfiling = casADi__CasadiOptions__stopProfiling+
+ Casadi/Wrappers/Classes/CustomEvaluate.hs view
@@ -0,0 +1,58 @@+{-# OPTIONS_GHC -Wall #-}+{-# OPTIONS_GHC -fno-warn-unused-imports #-}+{-# OPTIONS_GHC -fno-warn-orphans #-}+{-# Language ForeignFunctionInterface #-}+{-# Language FlexibleInstances #-}+{-# Language MultiParamTypeClasses #-}++module Casadi.Wrappers.Classes.CustomEvaluate+ (+ CustomEvaluate,+ CustomEvaluateClass(..),+ customEvaluate,+ ) where+++import Prelude hiding ( Functor )++import Data.Vector ( Vector )+import Foreign.C.Types+import Foreign.Ptr ( Ptr )+import Foreign.ForeignPtr ( newForeignPtr )+import System.IO.Unsafe ( unsafePerformIO ) -- for show instances++import Casadi.Wrappers.Classes.PrintableObject+import Casadi.Wrappers.ForeignToolsInstances ( )+import Casadi.Wrappers.Deleters+import Casadi.Wrappers.Data+import Casadi.Wrappers.Enums+import Casadi.MarshalTypes ( CppVec, CppVecVec, CppVecVecVec,+ StdString', CppBool' ) -- StdOstream'+import Casadi.Marshal ( CornerCase(..), Marshal(..) )+import Casadi.WrapReturn ( WrapReturn(..) )++instance Show CustomEvaluate where+ show = unsafePerformIO . printableObject_getDescription+-- direct wrapper+foreign import ccall unsafe "CasADi__CustomEvaluate__CustomEvaluate" c_CasADi__CustomEvaluate__CustomEvaluate+ :: IO (Ptr CustomEvaluate')+casADi__CustomEvaluate__CustomEvaluate+ :: IO CustomEvaluate+casADi__CustomEvaluate__CustomEvaluate =+ c_CasADi__CustomEvaluate__CustomEvaluate >>= (newForeignPtr c_delete_CasADi__CustomEvaluate) >>= wrapReturn++-- classy wrapper+{-|+>> CasADi::CustomEvaluate::CustomEvaluate()+>------------------------------------------------------------------------+>+>Default constructor.+>+>> CasADi::CustomEvaluate::CustomEvaluate(CustomEvaluateCPtr ptr)+>------------------------------------------------------------------------+>+>Construct from C pointer.+-}+customEvaluate :: IO CustomEvaluate+customEvaluate = casADi__CustomEvaluate__CustomEvaluate+
+ Casadi/Wrappers/Classes/CustomFunction.hs view
@@ -0,0 +1,119 @@+{-# OPTIONS_GHC -Wall #-}+{-# OPTIONS_GHC -fno-warn-unused-imports #-}+{-# OPTIONS_GHC -fno-warn-orphans #-}+{-# Language ForeignFunctionInterface #-}+{-# Language FlexibleInstances #-}+{-# Language MultiParamTypeClasses #-}++module Casadi.Wrappers.Classes.CustomFunction+ (+ CustomFunction,+ CustomFunctionClass(..),+ customFunction,+ customFunction',+ customFunction''''',+ customFunction_checkNode,+ ) where+++import Prelude hiding ( Functor )++import Data.Vector ( Vector )+import Foreign.C.Types+import Foreign.Ptr ( Ptr )+import Foreign.ForeignPtr ( newForeignPtr )+import System.IO.Unsafe ( unsafePerformIO ) -- for show instances++import Casadi.Wrappers.Classes.PrintableObject+import Casadi.Wrappers.ForeignToolsInstances ( )+import Casadi.Wrappers.Deleters+import Casadi.Wrappers.Data+import Casadi.Wrappers.Enums+import Casadi.MarshalTypes ( CppVec, CppVecVec, CppVecVecVec,+ StdString', CppBool' ) -- StdOstream'+import Casadi.Marshal ( CornerCase(..), Marshal(..) )+import Casadi.WrapReturn ( WrapReturn(..) )++instance Show CustomFunction where+ show = unsafePerformIO . printableObject_getDescription+-- direct wrapper+foreign import ccall unsafe "CasADi__CustomFunction__checkNode" c_CasADi__CustomFunction__checkNode+ :: Ptr CustomFunction' -> IO (Ptr CppBool')+casADi__CustomFunction__checkNode+ :: CustomFunction -> IO Bool+casADi__CustomFunction__checkNode x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__CustomFunction__checkNode x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++-- classy wrapper+{-|+>Check if the pointer points towards a valid object.+-}+customFunction_checkNode :: CustomFunctionClass a => a -> IO Bool+customFunction_checkNode x = casADi__CustomFunction__checkNode (castCustomFunction x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__CustomFunction__CustomFunction" c_CasADi__CustomFunction__CustomFunction+ :: IO (Ptr CustomFunction')+casADi__CustomFunction__CustomFunction+ :: IO CustomFunction+casADi__CustomFunction__CustomFunction =+ c_CasADi__CustomFunction__CustomFunction >>= (newForeignPtr c_delete_CasADi__CustomFunction) >>= wrapReturn++-- classy wrapper+{-|+>> CasADi::CustomFunction::CustomFunction(const CustomEvaluate &c_fcn, const std::vector< CRSSparsity > &inputscheme, const std::vector< CRSSparsity > &outputscheme)+>+>> CasADi::CustomFunction::CustomFunction(const CustomEvaluate &c_fcn, const IOSchemeVector< CRSSparsity > &inputscheme, const std::vector< CRSSparsity > &outputscheme)+>+>> CasADi::CustomFunction::CustomFunction(const CustomEvaluate &c_fcn, const std::vector< CRSSparsity > &inputscheme, const IOSchemeVector< CRSSparsity > &outputscheme)+>+>> CasADi::CustomFunction::CustomFunction(const CustomEvaluate &c_fcn, const IOSchemeVector< CRSSparsity > &inputscheme, const IOSchemeVector< CRSSparsity > &outputscheme)+>------------------------------------------------------------------------+>+>Create a function with input/output schemes given.+>+>> CasADi::CustomFunction::CustomFunction()+>------------------------------------------------------------------------+>+>default constructor+>+>> CasADi::CustomFunction::CustomFunction(const CustomEvaluate &c_fcn)+>------------------------------------------------------------------------+>+>Create a function, user sets inputs outputs manually.+-}+customFunction :: IO CustomFunction+customFunction = casADi__CustomFunction__CustomFunction+++-- direct wrapper+foreign import ccall unsafe "CasADi__CustomFunction__CustomFunction_TIC" c_CasADi__CustomFunction__CustomFunction_TIC+ :: Ptr CustomEvaluate' -> Ptr (CppVec (Ptr CRSSparsity')) -> Ptr (CppVec (Ptr CRSSparsity')) -> IO (Ptr CustomFunction')+casADi__CustomFunction__CustomFunction'+ :: CustomEvaluate -> Vector CRSSparsity -> Vector CRSSparsity -> IO CustomFunction+casADi__CustomFunction__CustomFunction' x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__CustomFunction__CustomFunction_TIC x0' x1' x2' >>= (newForeignPtr c_delete_CasADi__CustomFunction) >>= wrapReturn++-- classy wrapper+customFunction' :: CustomEvaluate -> Vector CRSSparsity -> Vector CRSSparsity -> IO CustomFunction+customFunction' = casADi__CustomFunction__CustomFunction'+++-- direct wrapper+foreign import ccall unsafe "CasADi__CustomFunction__CustomFunction_TIC_TIC_TIC_TIC_TIC" c_CasADi__CustomFunction__CustomFunction_TIC_TIC_TIC_TIC_TIC+ :: Ptr CustomEvaluate' -> IO (Ptr CustomFunction')+casADi__CustomFunction__CustomFunction'''''+ :: CustomEvaluate -> IO CustomFunction+casADi__CustomFunction__CustomFunction''''' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__CustomFunction__CustomFunction_TIC_TIC_TIC_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__CustomFunction) >>= wrapReturn++-- classy wrapper+customFunction''''' :: CustomEvaluate -> IO CustomFunction+customFunction''''' = casADi__CustomFunction__CustomFunction'''''+
+ Casadi/Wrappers/Classes/DMatrix.hs view
@@ -0,0 +1,2681 @@+{-# OPTIONS_GHC -Wall #-}+{-# OPTIONS_GHC -fno-warn-unused-imports #-}+{-# OPTIONS_GHC -fno-warn-orphans #-}+{-# Language ForeignFunctionInterface #-}+{-# Language FlexibleInstances #-}+{-# Language MultiParamTypeClasses #-}++module Casadi.Wrappers.Classes.DMatrix+ (+ DMatrix,+ DMatrixClass(..),+ dmatrix,+ dmatrix',+ dmatrix'',+ dmatrix''',+ dmatrix'''',+ dmatrix''''',+ dmatrix'''''',+ dmatrix''''''',+ dmatrix'''''''',+ dmatrix''''''''',+ dmatrix'''''''''',+ dmatrix''''''''''',+ dmatrix'''''''''''',+ dmatrix___add__,+ dmatrix___constpow__,+ dmatrix___div__,+ dmatrix___eq__,+ dmatrix___le__,+ dmatrix___lt__,+ dmatrix___mpower__,+ dmatrix___mrdivide__,+ dmatrix___mul__,+ dmatrix___ne__,+ dmatrix___nonzero__,+ dmatrix___pow__,+ dmatrix___sub__,+ dmatrix___truediv__,+ dmatrix_append,+ dmatrix_arccos,+ dmatrix_arccosh,+ dmatrix_arcsin,+ dmatrix_arcsinh,+ dmatrix_arctan,+ dmatrix_arctan2,+ dmatrix_arctanh,+ dmatrix_at,+ dmatrix_binary,+ dmatrix_ceil,+ dmatrix_className,+ dmatrix_clear,+ dmatrix_col,+ dmatrix_cos,+ dmatrix_cosh,+ dmatrix_data,+ dmatrix_elem,+ dmatrix_elem',+ dmatrix_enlarge,+ dmatrix_erase,+ dmatrix_erf,+ dmatrix_erfinv,+ dmatrix_exp,+ dmatrix_eye,+ dmatrix_fabs,+ dmatrix_floor,+ dmatrix_fmax,+ dmatrix_fmin,+ dmatrix_get,+ dmatrix_get',+ dmatrix_get'',+ dmatrix_get''',+ dmatrix_get'''',+ dmatrix_get''''',+ dmatrix_hasNZ,+ dmatrix_if_else_zero,+ dmatrix_inf,+ dmatrix_inf',+ dmatrix_inf'',+ dmatrix_inf''',+ dmatrix_isNull,+ dmatrix_log,+ dmatrix_log10,+ dmatrix_logic_and,+ dmatrix_logic_not,+ dmatrix_logic_or,+ dmatrix_matrix_matrix,+ dmatrix_matrix_scalar,+ dmatrix_mul,+ dmatrix_mul',+ dmatrix_mul_full,+ dmatrix_mul_full',+ dmatrix_mul_no_alloc_nn,+ dmatrix_mul_no_alloc_nn',+ dmatrix_mul_no_alloc_nt,+ dmatrix_mul_no_alloc_tn,+ dmatrix_mul_no_alloc_tn',+ dmatrix_nan,+ dmatrix_nan',+ dmatrix_nan'',+ dmatrix_nan''',+ dmatrix_numel,+ dmatrix_ones,+ dmatrix_ones',+ dmatrix_ones'',+ dmatrix_operator_minus,+ dmatrix_operator_plus,+ dmatrix_printDense',+ dmatrix_printMatrix',+ dmatrix_printScalar',+ dmatrix_printSparse',+ dmatrix_printVector',+ dmatrix_printme,+ dmatrix_quad_form,+ dmatrix_remove,+ dmatrix_repmat,+ dmatrix_repmat',+ dmatrix_reserve,+ dmatrix_reserve',+ dmatrix_resize,+ dmatrix_rowind,+ dmatrix_sanityCheck,+ dmatrix_sanityCheck',+ dmatrix_scalar_matrix,+ dmatrix_set,+ dmatrix_set',+ dmatrix_set'',+ dmatrix_set''',+ dmatrix_set'''',+ dmatrix_set''''',+ dmatrix_setPrecision,+ dmatrix_setScientific,+ dmatrix_setWidth,+ dmatrix_sign,+ dmatrix_sin,+ dmatrix_sinh,+ dmatrix_size,+ dmatrix_size1,+ dmatrix_size2,+ dmatrix_sparse,+ dmatrix_sparse',+ dmatrix_sparse'',+ dmatrix_sparse''',+ dmatrix_sparsityRef,+ dmatrix_sqrt,+ dmatrix_tan,+ dmatrix_tanh,+ dmatrix_trans,+ dmatrix_unary,+ dmatrix_vector,+ dmatrix_zeros,+ dmatrix_zeros',+ dmatrix_zeros'',+ ) where+++import Prelude hiding ( Functor )++import Data.Vector ( Vector )+import Foreign.C.Types+import Foreign.Ptr ( Ptr )+import Foreign.ForeignPtr ( newForeignPtr )+import System.IO.Unsafe ( unsafePerformIO ) -- for show instances++import Casadi.Wrappers.Classes.PrintableObject+import Casadi.Wrappers.ForeignToolsInstances ( )+import Casadi.Wrappers.Deleters+import Casadi.Wrappers.Data+import Casadi.Wrappers.Enums+import Casadi.MarshalTypes ( CppVec, CppVecVec, CppVecVecVec,+ StdString', CppBool' ) -- StdOstream'+import Casadi.Marshal ( CornerCase(..), Marshal(..) )+import Casadi.WrapReturn ( WrapReturn(..) )++instance Show DMatrix where+ show = unsafePerformIO . printableObject_getDescription+-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___size1" c_CasADi__Matrix_double___size1+ :: Ptr DMatrix' -> IO CInt+casADi__Matrix_double___size1+ :: DMatrix -> IO Int+casADi__Matrix_double___size1 x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_double___size1 x0' >>= wrapReturn++-- classy wrapper+dmatrix_size1 :: DMatrixClass a => a -> IO Int+dmatrix_size1 x = casADi__Matrix_double___size1 (castDMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___size2" c_CasADi__Matrix_double___size2+ :: Ptr DMatrix' -> IO CInt+casADi__Matrix_double___size2+ :: DMatrix -> IO Int+casADi__Matrix_double___size2 x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_double___size2 x0' >>= wrapReturn++-- classy wrapper+dmatrix_size2 :: DMatrixClass a => a -> IO Int+dmatrix_size2 x = casADi__Matrix_double___size2 (castDMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___size" c_CasADi__Matrix_double___size+ :: Ptr DMatrix' -> IO CInt+casADi__Matrix_double___size+ :: DMatrix -> IO Int+casADi__Matrix_double___size x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_double___size x0' >>= wrapReturn++-- classy wrapper+dmatrix_size :: DMatrixClass a => a -> IO Int+dmatrix_size x = casADi__Matrix_double___size (castDMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___numel" c_CasADi__Matrix_double___numel+ :: Ptr DMatrix' -> IO CInt+casADi__Matrix_double___numel+ :: DMatrix -> IO Int+casADi__Matrix_double___numel x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_double___numel x0' >>= wrapReturn++-- classy wrapper+dmatrix_numel :: DMatrixClass a => a -> IO Int+dmatrix_numel x = casADi__Matrix_double___numel (castDMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___sanityCheck" c_CasADi__Matrix_double___sanityCheck+ :: Ptr DMatrix' -> Ptr CppBool' -> IO ()+casADi__Matrix_double___sanityCheck+ :: DMatrix -> Bool -> IO ()+casADi__Matrix_double___sanityCheck x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__Matrix_double___sanityCheck x0' x1' >>= wrapReturn++-- classy wrapper+{-|+>Check if the dimensions and rowind,col vectors are compatible.+>+>Parameters:+>-----------+>+>complete: set to true to also check elementwise throws an error as possible+>result+-}+dmatrix_sanityCheck :: DMatrixClass a => a -> Bool -> IO ()+dmatrix_sanityCheck x = casADi__Matrix_double___sanityCheck (castDMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___sanityCheck_TIC" c_CasADi__Matrix_double___sanityCheck_TIC+ :: Ptr DMatrix' -> IO ()+casADi__Matrix_double___sanityCheck'+ :: DMatrix -> IO ()+casADi__Matrix_double___sanityCheck' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_double___sanityCheck_TIC x0' >>= wrapReturn++-- classy wrapper+dmatrix_sanityCheck' :: DMatrixClass a => a -> IO ()+dmatrix_sanityCheck' x = casADi__Matrix_double___sanityCheck' (castDMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___vector" c_CasADi__Matrix_double___vector+ :: Ptr DMatrix' -> IO (Ptr CppBool')+casADi__Matrix_double___vector+ :: DMatrix -> IO Bool+casADi__Matrix_double___vector x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_double___vector x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++-- classy wrapper+{-|+>ublas vector+>+>Check type of matrix+-}+dmatrix_vector :: DMatrixClass a => a -> IO Bool+dmatrix_vector x = casADi__Matrix_double___vector (castDMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___at" c_CasADi__Matrix_double___at+ :: Ptr DMatrix' -> CInt -> IO CDouble+casADi__Matrix_double___at+ :: DMatrix -> Int -> IO Double+casADi__Matrix_double___at x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__Matrix_double___at x0' x1' >>= wrapReturn++-- classy wrapper+{-|+>> const T& CasADi::Matrix< T >::at(int k) const +>------------------------------------------------------------------------+>+>Get a non-zero element.+>+>> T& CasADi::Matrix< T >::at(int k)+>------------------------------------------------------------------------+>+>Access a non-zero element.+-}+dmatrix_at :: DMatrixClass a => a -> Int -> IO Double+dmatrix_at x = casADi__Matrix_double___at (castDMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___elem" c_CasADi__Matrix_double___elem+ :: Ptr DMatrix' -> CInt -> CInt -> IO CDouble+casADi__Matrix_double___elem+ :: DMatrix -> Int -> Int -> IO Double+casADi__Matrix_double___elem x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__Matrix_double___elem x0' x1' x2' >>= wrapReturn++-- classy wrapper+{-|+>> const T & CasADi::Matrix< T >::elem(int i, int j=0) const +>------------------------------------------------------------------------+>+>get an element+>+>> T & CasADi::Matrix< T >::elem(int i, int j=0)+>------------------------------------------------------------------------+>+>get a reference to an element+-}+dmatrix_elem :: DMatrixClass a => a -> Int -> Int -> IO Double+dmatrix_elem x = casADi__Matrix_double___elem (castDMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___elem_TIC" c_CasADi__Matrix_double___elem_TIC+ :: Ptr DMatrix' -> CInt -> IO CDouble+casADi__Matrix_double___elem'+ :: DMatrix -> Int -> IO Double+casADi__Matrix_double___elem' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__Matrix_double___elem_TIC x0' x1' >>= wrapReturn++-- classy wrapper+dmatrix_elem' :: DMatrixClass a => a -> Int -> IO Double+dmatrix_elem' x = casADi__Matrix_double___elem' (castDMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___hasNZ" c_CasADi__Matrix_double___hasNZ+ :: Ptr DMatrix' -> CInt -> CInt -> IO (Ptr CppBool')+casADi__Matrix_double___hasNZ+ :: DMatrix -> Int -> Int -> IO Bool+casADi__Matrix_double___hasNZ x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__Matrix_double___hasNZ x0' x1' x2' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++-- classy wrapper+{-|+>Returns true if the matrix has a non-zero at location i,j.+-}+dmatrix_hasNZ :: DMatrixClass a => a -> Int -> Int -> IO Bool+dmatrix_hasNZ x = casADi__Matrix_double___hasNZ (castDMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double_____nonzero__" c_CasADi__Matrix_double_____nonzero__+ :: Ptr DMatrix' -> IO (Ptr CppBool')+casADi__Matrix_double_____nonzero__+ :: DMatrix -> IO Bool+casADi__Matrix_double_____nonzero__ x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_double_____nonzero__ x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++-- classy wrapper+{-|+>Returns the truth value of a Matrix.+-}+dmatrix___nonzero__ :: DMatrixClass a => a -> IO Bool+dmatrix___nonzero__ x = casADi__Matrix_double_____nonzero__ (castDMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___append" c_CasADi__Matrix_double___append+ :: Ptr DMatrix' -> Ptr DMatrix' -> IO ()+casADi__Matrix_double___append+ :: DMatrix -> DMatrix -> IO ()+casADi__Matrix_double___append x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__Matrix_double___append x0' x1' >>= wrapReturn++-- classy wrapper+{-|+>Append a matrix to the end.+-}+dmatrix_append :: DMatrixClass a => a -> DMatrix -> IO ()+dmatrix_append x = casADi__Matrix_double___append (castDMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___operator_plus" c_CasADi__Matrix_double___operator_plus+ :: Ptr DMatrix' -> IO (Ptr DMatrix')+casADi__Matrix_double___operator_plus+ :: DMatrix -> IO DMatrix+casADi__Matrix_double___operator_plus x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_double___operator_plus x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++-- classy wrapper+dmatrix_operator_plus :: DMatrixClass a => a -> IO DMatrix+dmatrix_operator_plus x = casADi__Matrix_double___operator_plus (castDMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___operator_minus" c_CasADi__Matrix_double___operator_minus+ :: Ptr DMatrix' -> IO (Ptr DMatrix')+casADi__Matrix_double___operator_minus+ :: DMatrix -> IO DMatrix+casADi__Matrix_double___operator_minus x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_double___operator_minus x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++-- classy wrapper+dmatrix_operator_minus :: DMatrixClass a => a -> IO DMatrix+dmatrix_operator_minus x = casADi__Matrix_double___operator_minus (castDMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___binary" c_CasADi__Matrix_double___binary+ :: CInt -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')+casADi__Matrix_double___binary+ :: Int -> DMatrix -> DMatrix -> IO DMatrix+casADi__Matrix_double___binary x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__Matrix_double___binary x0' x1' x2' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++-- classy wrapper+{-|+>Create nodes by their ID.+-}+dmatrix_binary :: Int -> DMatrix -> DMatrix -> IO DMatrix+dmatrix_binary = casADi__Matrix_double___binary+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___unary" c_CasADi__Matrix_double___unary+ :: CInt -> Ptr DMatrix' -> IO (Ptr DMatrix')+casADi__Matrix_double___unary+ :: Int -> DMatrix -> IO DMatrix+casADi__Matrix_double___unary x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__Matrix_double___unary x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++-- classy wrapper+{-|+>Create nodes by their ID.+-}+dmatrix_unary :: Int -> DMatrix -> IO DMatrix+dmatrix_unary = casADi__Matrix_double___unary+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___scalar_matrix" c_CasADi__Matrix_double___scalar_matrix+ :: CInt -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')+casADi__Matrix_double___scalar_matrix+ :: Int -> DMatrix -> DMatrix -> IO DMatrix+casADi__Matrix_double___scalar_matrix x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__Matrix_double___scalar_matrix x0' x1' x2' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++-- classy wrapper+{-|+>Create nodes by their ID.+-}+dmatrix_scalar_matrix :: Int -> DMatrix -> DMatrix -> IO DMatrix+dmatrix_scalar_matrix = casADi__Matrix_double___scalar_matrix+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___matrix_scalar" c_CasADi__Matrix_double___matrix_scalar+ :: CInt -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')+casADi__Matrix_double___matrix_scalar+ :: Int -> DMatrix -> DMatrix -> IO DMatrix+casADi__Matrix_double___matrix_scalar x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__Matrix_double___matrix_scalar x0' x1' x2' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++-- classy wrapper+{-|+>Create nodes by their ID.+-}+dmatrix_matrix_scalar :: Int -> DMatrix -> DMatrix -> IO DMatrix+dmatrix_matrix_scalar = casADi__Matrix_double___matrix_scalar+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___matrix_matrix" c_CasADi__Matrix_double___matrix_matrix+ :: CInt -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')+casADi__Matrix_double___matrix_matrix+ :: Int -> DMatrix -> DMatrix -> IO DMatrix+casADi__Matrix_double___matrix_matrix x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__Matrix_double___matrix_matrix x0' x1' x2' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++-- classy wrapper+{-|+>Create nodes by their ID.+-}+dmatrix_matrix_matrix :: Int -> DMatrix -> DMatrix -> IO DMatrix+dmatrix_matrix_matrix = casADi__Matrix_double___matrix_matrix+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double_____add__" c_CasADi__Matrix_double_____add__+ :: Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')+casADi__Matrix_double_____add__+ :: DMatrix -> DMatrix -> IO DMatrix+casADi__Matrix_double_____add__ x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__Matrix_double_____add__ x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++-- classy wrapper+{-|+>Elementwise operations Octave/Python naming.+-}+dmatrix___add__ :: DMatrixClass a => a -> DMatrix -> IO DMatrix+dmatrix___add__ x = casADi__Matrix_double_____add__ (castDMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double_____sub__" c_CasADi__Matrix_double_____sub__+ :: Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')+casADi__Matrix_double_____sub__+ :: DMatrix -> DMatrix -> IO DMatrix+casADi__Matrix_double_____sub__ x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__Matrix_double_____sub__ x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++-- classy wrapper+{-|+>Elementwise operations Octave/Python naming.+-}+dmatrix___sub__ :: DMatrixClass a => a -> DMatrix -> IO DMatrix+dmatrix___sub__ x = casADi__Matrix_double_____sub__ (castDMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double_____mul__" c_CasADi__Matrix_double_____mul__+ :: Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')+casADi__Matrix_double_____mul__+ :: DMatrix -> DMatrix -> IO DMatrix+casADi__Matrix_double_____mul__ x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__Matrix_double_____mul__ x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++-- classy wrapper+{-|+>Elementwise operations Octave/Python naming.+-}+dmatrix___mul__ :: DMatrixClass a => a -> DMatrix -> IO DMatrix+dmatrix___mul__ x = casADi__Matrix_double_____mul__ (castDMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double_____div__" c_CasADi__Matrix_double_____div__+ :: Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')+casADi__Matrix_double_____div__+ :: DMatrix -> DMatrix -> IO DMatrix+casADi__Matrix_double_____div__ x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__Matrix_double_____div__ x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++-- classy wrapper+{-|+>Elementwise operations Octave/Python naming.+-}+dmatrix___div__ :: DMatrixClass a => a -> DMatrix -> IO DMatrix+dmatrix___div__ x = casADi__Matrix_double_____div__ (castDMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double_____lt__" c_CasADi__Matrix_double_____lt__+ :: Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')+casADi__Matrix_double_____lt__+ :: DMatrix -> DMatrix -> IO DMatrix+casADi__Matrix_double_____lt__ x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__Matrix_double_____lt__ x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++-- classy wrapper+{-|+>Elementwise operations Octave/Python naming.+-}+dmatrix___lt__ :: DMatrixClass a => a -> DMatrix -> IO DMatrix+dmatrix___lt__ x = casADi__Matrix_double_____lt__ (castDMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double_____le__" c_CasADi__Matrix_double_____le__+ :: Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')+casADi__Matrix_double_____le__+ :: DMatrix -> DMatrix -> IO DMatrix+casADi__Matrix_double_____le__ x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__Matrix_double_____le__ x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++-- classy wrapper+{-|+>Elementwise operations Octave/Python naming.+-}+dmatrix___le__ :: DMatrixClass a => a -> DMatrix -> IO DMatrix+dmatrix___le__ x = casADi__Matrix_double_____le__ (castDMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double_____eq__" c_CasADi__Matrix_double_____eq__+ :: Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')+casADi__Matrix_double_____eq__+ :: DMatrix -> DMatrix -> IO DMatrix+casADi__Matrix_double_____eq__ x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__Matrix_double_____eq__ x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++-- classy wrapper+{-|+>Elementwise operations Octave/Python naming.+-}+dmatrix___eq__ :: DMatrixClass a => a -> DMatrix -> IO DMatrix+dmatrix___eq__ x = casADi__Matrix_double_____eq__ (castDMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double_____ne__" c_CasADi__Matrix_double_____ne__+ :: Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')+casADi__Matrix_double_____ne__+ :: DMatrix -> DMatrix -> IO DMatrix+casADi__Matrix_double_____ne__ x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__Matrix_double_____ne__ x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++-- classy wrapper+{-|+>Elementwise operations Octave/Python naming.+-}+dmatrix___ne__ :: DMatrixClass a => a -> DMatrix -> IO DMatrix+dmatrix___ne__ x = casADi__Matrix_double_____ne__ (castDMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double_____truediv__" c_CasADi__Matrix_double_____truediv__+ :: Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')+casADi__Matrix_double_____truediv__+ :: DMatrix -> DMatrix -> IO DMatrix+casADi__Matrix_double_____truediv__ x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__Matrix_double_____truediv__ x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++-- classy wrapper+{-|+>Elementwise operations Octave/Python naming.+-}+dmatrix___truediv__ :: DMatrixClass a => a -> DMatrix -> IO DMatrix+dmatrix___truediv__ x = casADi__Matrix_double_____truediv__ (castDMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double_____pow__" c_CasADi__Matrix_double_____pow__+ :: Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')+casADi__Matrix_double_____pow__+ :: DMatrix -> DMatrix -> IO DMatrix+casADi__Matrix_double_____pow__ x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__Matrix_double_____pow__ x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++-- classy wrapper+{-|+>Elementwise operations Octave/Python naming.+-}+dmatrix___pow__ :: DMatrixClass a => a -> DMatrix -> IO DMatrix+dmatrix___pow__ x = casADi__Matrix_double_____pow__ (castDMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double_____constpow__" c_CasADi__Matrix_double_____constpow__+ :: Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')+casADi__Matrix_double_____constpow__+ :: DMatrix -> DMatrix -> IO DMatrix+casADi__Matrix_double_____constpow__ x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__Matrix_double_____constpow__ x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++-- classy wrapper+{-|+>Elementwise operations Octave/Python naming.+-}+dmatrix___constpow__ :: DMatrixClass a => a -> DMatrix -> IO DMatrix+dmatrix___constpow__ x = casADi__Matrix_double_____constpow__ (castDMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double_____mpower__" c_CasADi__Matrix_double_____mpower__+ :: Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')+casADi__Matrix_double_____mpower__+ :: DMatrix -> DMatrix -> IO DMatrix+casADi__Matrix_double_____mpower__ x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__Matrix_double_____mpower__ x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++-- classy wrapper+{-|+>Elementwise operations Octave/Python naming.+-}+dmatrix___mpower__ :: DMatrixClass a => a -> DMatrix -> IO DMatrix+dmatrix___mpower__ x = casADi__Matrix_double_____mpower__ (castDMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double_____mrdivide__" c_CasADi__Matrix_double_____mrdivide__+ :: Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')+casADi__Matrix_double_____mrdivide__+ :: DMatrix -> DMatrix -> IO DMatrix+casADi__Matrix_double_____mrdivide__ x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__Matrix_double_____mrdivide__ x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++-- classy wrapper+{-|+>Elementwise operations Octave/Python naming.+-}+dmatrix___mrdivide__ :: DMatrixClass a => a -> DMatrix -> IO DMatrix+dmatrix___mrdivide__ x = casADi__Matrix_double_____mrdivide__ (castDMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___mul_full" c_CasADi__Matrix_double___mul_full+ :: Ptr DMatrix' -> Ptr DMatrix' -> Ptr CRSSparsity' -> IO (Ptr DMatrix')+casADi__Matrix_double___mul_full+ :: DMatrix -> DMatrix -> CRSSparsity -> IO DMatrix+casADi__Matrix_double___mul_full x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__Matrix_double___mul_full x0' x1' x2' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++-- classy wrapper+{-|+>Matrix-matrix product.+-}+dmatrix_mul_full :: DMatrixClass a => a -> DMatrix -> CRSSparsity -> IO DMatrix+dmatrix_mul_full x = casADi__Matrix_double___mul_full (castDMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___mul_full_TIC" c_CasADi__Matrix_double___mul_full_TIC+ :: Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')+casADi__Matrix_double___mul_full'+ :: DMatrix -> DMatrix -> IO DMatrix+casADi__Matrix_double___mul_full' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__Matrix_double___mul_full_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++-- classy wrapper+dmatrix_mul_full' :: DMatrixClass a => a -> DMatrix -> IO DMatrix+dmatrix_mul_full' x = casADi__Matrix_double___mul_full' (castDMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___mul" c_CasADi__Matrix_double___mul+ :: Ptr DMatrix' -> Ptr DMatrix' -> Ptr CRSSparsity' -> IO (Ptr DMatrix')+casADi__Matrix_double___mul+ :: DMatrix -> DMatrix -> CRSSparsity -> IO DMatrix+casADi__Matrix_double___mul x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__Matrix_double___mul x0' x1' x2' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++-- classy wrapper+{-|+>Matrix-matrix product.+-}+dmatrix_mul :: DMatrixClass a => a -> DMatrix -> CRSSparsity -> IO DMatrix+dmatrix_mul x = casADi__Matrix_double___mul (castDMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___mul_TIC" c_CasADi__Matrix_double___mul_TIC+ :: Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')+casADi__Matrix_double___mul'+ :: DMatrix -> DMatrix -> IO DMatrix+casADi__Matrix_double___mul' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__Matrix_double___mul_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++-- classy wrapper+dmatrix_mul' :: DMatrixClass a => a -> DMatrix -> IO DMatrix+dmatrix_mul' x = casADi__Matrix_double___mul' (castDMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___mul_no_alloc_nn" c_CasADi__Matrix_double___mul_no_alloc_nn+ :: Ptr DMatrix' -> Ptr DMatrix' -> Ptr DMatrix' -> IO ()+casADi__Matrix_double___mul_no_alloc_nn+ :: DMatrix -> DMatrix -> DMatrix -> IO ()+casADi__Matrix_double___mul_no_alloc_nn x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__Matrix_double___mul_no_alloc_nn x0' x1' x2' >>= wrapReturn++-- classy wrapper+dmatrix_mul_no_alloc_nn :: DMatrix -> DMatrix -> DMatrix -> IO ()+dmatrix_mul_no_alloc_nn = casADi__Matrix_double___mul_no_alloc_nn+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___mul_no_alloc_nt" c_CasADi__Matrix_double___mul_no_alloc_nt+ :: Ptr DMatrix' -> Ptr DMatrix' -> Ptr DMatrix' -> IO ()+casADi__Matrix_double___mul_no_alloc_nt+ :: DMatrix -> DMatrix -> DMatrix -> IO ()+casADi__Matrix_double___mul_no_alloc_nt x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__Matrix_double___mul_no_alloc_nt x0' x1' x2' >>= wrapReturn++-- classy wrapper+dmatrix_mul_no_alloc_nt :: DMatrix -> DMatrix -> DMatrix -> IO ()+dmatrix_mul_no_alloc_nt = casADi__Matrix_double___mul_no_alloc_nt+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___mul_no_alloc_tn" c_CasADi__Matrix_double___mul_no_alloc_tn+ :: Ptr DMatrix' -> Ptr DMatrix' -> Ptr DMatrix' -> IO ()+casADi__Matrix_double___mul_no_alloc_tn+ :: DMatrix -> DMatrix -> DMatrix -> IO ()+casADi__Matrix_double___mul_no_alloc_tn x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__Matrix_double___mul_no_alloc_tn x0' x1' x2' >>= wrapReturn++-- classy wrapper+dmatrix_mul_no_alloc_tn :: DMatrix -> DMatrix -> DMatrix -> IO ()+dmatrix_mul_no_alloc_tn = casADi__Matrix_double___mul_no_alloc_tn+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___mul_no_alloc_nn_TIC" c_CasADi__Matrix_double___mul_no_alloc_nn_TIC+ :: Ptr DMatrix' -> Ptr (CppVec CDouble) -> Ptr (CppVec CDouble) -> IO ()+casADi__Matrix_double___mul_no_alloc_nn'+ :: DMatrix -> Vector Double -> Vector Double -> IO ()+casADi__Matrix_double___mul_no_alloc_nn' x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__Matrix_double___mul_no_alloc_nn_TIC x0' x1' x2' >>= wrapReturn++-- classy wrapper+dmatrix_mul_no_alloc_nn' :: DMatrix -> Vector Double -> Vector Double -> IO ()+dmatrix_mul_no_alloc_nn' = casADi__Matrix_double___mul_no_alloc_nn'+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___mul_no_alloc_tn_TIC" c_CasADi__Matrix_double___mul_no_alloc_tn_TIC+ :: Ptr DMatrix' -> Ptr (CppVec CDouble) -> Ptr (CppVec CDouble) -> IO ()+casADi__Matrix_double___mul_no_alloc_tn'+ :: DMatrix -> Vector Double -> Vector Double -> IO ()+casADi__Matrix_double___mul_no_alloc_tn' x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__Matrix_double___mul_no_alloc_tn_TIC x0' x1' x2' >>= wrapReturn++-- classy wrapper+dmatrix_mul_no_alloc_tn' :: DMatrix -> Vector Double -> Vector Double -> IO ()+dmatrix_mul_no_alloc_tn' = casADi__Matrix_double___mul_no_alloc_tn'+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___quad_form" c_CasADi__Matrix_double___quad_form+ :: Ptr DMatrix' -> Ptr (CppVec CDouble) -> IO CDouble+casADi__Matrix_double___quad_form+ :: DMatrix -> Vector Double -> IO Double+casADi__Matrix_double___quad_form x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__Matrix_double___quad_form x0' x1' >>= wrapReturn++-- classy wrapper+dmatrix_quad_form :: DMatrix -> Vector Double -> IO Double+dmatrix_quad_form = casADi__Matrix_double___quad_form+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___trans" c_CasADi__Matrix_double___trans+ :: Ptr DMatrix' -> IO (Ptr DMatrix')+casADi__Matrix_double___trans+ :: DMatrix -> IO DMatrix+casADi__Matrix_double___trans x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_double___trans x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++-- classy wrapper+{-|+>Matrix transpose.+-}+dmatrix_trans :: DMatrixClass a => a -> IO DMatrix+dmatrix_trans x = casADi__Matrix_double___trans (castDMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___sin" c_CasADi__Matrix_double___sin+ :: Ptr DMatrix' -> IO (Ptr DMatrix')+casADi__Matrix_double___sin+ :: DMatrix -> IO DMatrix+casADi__Matrix_double___sin x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_double___sin x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++-- classy wrapper+{-|+>Operations defined in the standard namespace for unambigous access and Numpy+>compatibility.+-}+dmatrix_sin :: DMatrixClass a => a -> IO DMatrix+dmatrix_sin x = casADi__Matrix_double___sin (castDMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___cos" c_CasADi__Matrix_double___cos+ :: Ptr DMatrix' -> IO (Ptr DMatrix')+casADi__Matrix_double___cos+ :: DMatrix -> IO DMatrix+casADi__Matrix_double___cos x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_double___cos x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++-- classy wrapper+{-|+>Operations defined in the standard namespace for unambigous access and Numpy+>compatibility.+-}+dmatrix_cos :: DMatrixClass a => a -> IO DMatrix+dmatrix_cos x = casADi__Matrix_double___cos (castDMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___tan" c_CasADi__Matrix_double___tan+ :: Ptr DMatrix' -> IO (Ptr DMatrix')+casADi__Matrix_double___tan+ :: DMatrix -> IO DMatrix+casADi__Matrix_double___tan x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_double___tan x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++-- classy wrapper+{-|+>Operations defined in the standard namespace for unambigous access and Numpy+>compatibility.+-}+dmatrix_tan :: DMatrixClass a => a -> IO DMatrix+dmatrix_tan x = casADi__Matrix_double___tan (castDMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___arcsin" c_CasADi__Matrix_double___arcsin+ :: Ptr DMatrix' -> IO (Ptr DMatrix')+casADi__Matrix_double___arcsin+ :: DMatrix -> IO DMatrix+casADi__Matrix_double___arcsin x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_double___arcsin x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++-- classy wrapper+{-|+>Operations defined in the standard namespace for unambigous access and Numpy+>compatibility.+-}+dmatrix_arcsin :: DMatrixClass a => a -> IO DMatrix+dmatrix_arcsin x = casADi__Matrix_double___arcsin (castDMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___arccos" c_CasADi__Matrix_double___arccos+ :: Ptr DMatrix' -> IO (Ptr DMatrix')+casADi__Matrix_double___arccos+ :: DMatrix -> IO DMatrix+casADi__Matrix_double___arccos x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_double___arccos x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++-- classy wrapper+{-|+>Operations defined in the standard namespace for unambigous access and Numpy+>compatibility.+-}+dmatrix_arccos :: DMatrixClass a => a -> IO DMatrix+dmatrix_arccos x = casADi__Matrix_double___arccos (castDMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___arctan" c_CasADi__Matrix_double___arctan+ :: Ptr DMatrix' -> IO (Ptr DMatrix')+casADi__Matrix_double___arctan+ :: DMatrix -> IO DMatrix+casADi__Matrix_double___arctan x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_double___arctan x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++-- classy wrapper+{-|+>Operations defined in the standard namespace for unambigous access and Numpy+>compatibility.+-}+dmatrix_arctan :: DMatrixClass a => a -> IO DMatrix+dmatrix_arctan x = casADi__Matrix_double___arctan (castDMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___exp" c_CasADi__Matrix_double___exp+ :: Ptr DMatrix' -> IO (Ptr DMatrix')+casADi__Matrix_double___exp+ :: DMatrix -> IO DMatrix+casADi__Matrix_double___exp x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_double___exp x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++-- classy wrapper+{-|+>Operations defined in the standard namespace for unambigous access and Numpy+>compatibility.+-}+dmatrix_exp :: DMatrixClass a => a -> IO DMatrix+dmatrix_exp x = casADi__Matrix_double___exp (castDMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___log" c_CasADi__Matrix_double___log+ :: Ptr DMatrix' -> IO (Ptr DMatrix')+casADi__Matrix_double___log+ :: DMatrix -> IO DMatrix+casADi__Matrix_double___log x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_double___log x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++-- classy wrapper+{-|+>Operations defined in the standard namespace for unambigous access and Numpy+>compatibility.+-}+dmatrix_log :: DMatrixClass a => a -> IO DMatrix+dmatrix_log x = casADi__Matrix_double___log (castDMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___sqrt" c_CasADi__Matrix_double___sqrt+ :: Ptr DMatrix' -> IO (Ptr DMatrix')+casADi__Matrix_double___sqrt+ :: DMatrix -> IO DMatrix+casADi__Matrix_double___sqrt x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_double___sqrt x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++-- classy wrapper+{-|+>Operations defined in the standard namespace for unambigous access and Numpy+>compatibility.+-}+dmatrix_sqrt :: DMatrixClass a => a -> IO DMatrix+dmatrix_sqrt x = casADi__Matrix_double___sqrt (castDMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___floor" c_CasADi__Matrix_double___floor+ :: Ptr DMatrix' -> IO (Ptr DMatrix')+casADi__Matrix_double___floor+ :: DMatrix -> IO DMatrix+casADi__Matrix_double___floor x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_double___floor x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++-- classy wrapper+{-|+>Operations defined in the standard namespace for unambigous access and Numpy+>compatibility.+-}+dmatrix_floor :: DMatrixClass a => a -> IO DMatrix+dmatrix_floor x = casADi__Matrix_double___floor (castDMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___ceil" c_CasADi__Matrix_double___ceil+ :: Ptr DMatrix' -> IO (Ptr DMatrix')+casADi__Matrix_double___ceil+ :: DMatrix -> IO DMatrix+casADi__Matrix_double___ceil x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_double___ceil x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++-- classy wrapper+{-|+>Operations defined in the standard namespace for unambigous access and Numpy+>compatibility.+-}+dmatrix_ceil :: DMatrixClass a => a -> IO DMatrix+dmatrix_ceil x = casADi__Matrix_double___ceil (castDMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___fabs" c_CasADi__Matrix_double___fabs+ :: Ptr DMatrix' -> IO (Ptr DMatrix')+casADi__Matrix_double___fabs+ :: DMatrix -> IO DMatrix+casADi__Matrix_double___fabs x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_double___fabs x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++-- classy wrapper+{-|+>Operations defined in the standard namespace for unambigous access and Numpy+>compatibility.+-}+dmatrix_fabs :: DMatrixClass a => a -> IO DMatrix+dmatrix_fabs x = casADi__Matrix_double___fabs (castDMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___sign" c_CasADi__Matrix_double___sign+ :: Ptr DMatrix' -> IO (Ptr DMatrix')+casADi__Matrix_double___sign+ :: DMatrix -> IO DMatrix+casADi__Matrix_double___sign x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_double___sign x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++-- classy wrapper+{-|+>Operations defined in the standard namespace for unambigous access and Numpy+>compatibility.+-}+dmatrix_sign :: DMatrixClass a => a -> IO DMatrix+dmatrix_sign x = casADi__Matrix_double___sign (castDMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___erfinv" c_CasADi__Matrix_double___erfinv+ :: Ptr DMatrix' -> IO (Ptr DMatrix')+casADi__Matrix_double___erfinv+ :: DMatrix -> IO DMatrix+casADi__Matrix_double___erfinv x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_double___erfinv x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++-- classy wrapper+{-|+>Operations defined in the standard namespace for unambigous access and Numpy+>compatibility.+-}+dmatrix_erfinv :: DMatrixClass a => a -> IO DMatrix+dmatrix_erfinv x = casADi__Matrix_double___erfinv (castDMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___fmin" c_CasADi__Matrix_double___fmin+ :: Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')+casADi__Matrix_double___fmin+ :: DMatrix -> DMatrix -> IO DMatrix+casADi__Matrix_double___fmin x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__Matrix_double___fmin x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++-- classy wrapper+{-|+>Operations defined in the standard namespace for unambigous access and Numpy+>compatibility.+-}+dmatrix_fmin :: DMatrixClass a => a -> DMatrix -> IO DMatrix+dmatrix_fmin x = casADi__Matrix_double___fmin (castDMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___fmax" c_CasADi__Matrix_double___fmax+ :: Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')+casADi__Matrix_double___fmax+ :: DMatrix -> DMatrix -> IO DMatrix+casADi__Matrix_double___fmax x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__Matrix_double___fmax x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++-- classy wrapper+{-|+>Operations defined in the standard namespace for unambigous access and Numpy+>compatibility.+-}+dmatrix_fmax :: DMatrixClass a => a -> DMatrix -> IO DMatrix+dmatrix_fmax x = casADi__Matrix_double___fmax (castDMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___erf" c_CasADi__Matrix_double___erf+ :: Ptr DMatrix' -> IO (Ptr DMatrix')+casADi__Matrix_double___erf+ :: DMatrix -> IO DMatrix+casADi__Matrix_double___erf x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_double___erf x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++-- classy wrapper+{-|+>Operations defined in the standard namespace for unambigous access and Numpy+>compatibility.+-}+dmatrix_erf :: DMatrixClass a => a -> IO DMatrix+dmatrix_erf x = casADi__Matrix_double___erf (castDMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___sinh" c_CasADi__Matrix_double___sinh+ :: Ptr DMatrix' -> IO (Ptr DMatrix')+casADi__Matrix_double___sinh+ :: DMatrix -> IO DMatrix+casADi__Matrix_double___sinh x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_double___sinh x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++-- classy wrapper+{-|+>Operations defined in the standard namespace for unambigous access and Numpy+>compatibility.+-}+dmatrix_sinh :: DMatrixClass a => a -> IO DMatrix+dmatrix_sinh x = casADi__Matrix_double___sinh (castDMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___cosh" c_CasADi__Matrix_double___cosh+ :: Ptr DMatrix' -> IO (Ptr DMatrix')+casADi__Matrix_double___cosh+ :: DMatrix -> IO DMatrix+casADi__Matrix_double___cosh x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_double___cosh x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++-- classy wrapper+{-|+>Operations defined in the standard namespace for unambigous access and Numpy+>compatibility.+-}+dmatrix_cosh :: DMatrixClass a => a -> IO DMatrix+dmatrix_cosh x = casADi__Matrix_double___cosh (castDMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___tanh" c_CasADi__Matrix_double___tanh+ :: Ptr DMatrix' -> IO (Ptr DMatrix')+casADi__Matrix_double___tanh+ :: DMatrix -> IO DMatrix+casADi__Matrix_double___tanh x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_double___tanh x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++-- classy wrapper+{-|+>Operations defined in the standard namespace for unambigous access and Numpy+>compatibility.+-}+dmatrix_tanh :: DMatrixClass a => a -> IO DMatrix+dmatrix_tanh x = casADi__Matrix_double___tanh (castDMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___arcsinh" c_CasADi__Matrix_double___arcsinh+ :: Ptr DMatrix' -> IO (Ptr DMatrix')+casADi__Matrix_double___arcsinh+ :: DMatrix -> IO DMatrix+casADi__Matrix_double___arcsinh x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_double___arcsinh x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++-- classy wrapper+{-|+>Operations defined in the standard namespace for unambigous access and Numpy+>compatibility.+-}+dmatrix_arcsinh :: DMatrixClass a => a -> IO DMatrix+dmatrix_arcsinh x = casADi__Matrix_double___arcsinh (castDMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___arccosh" c_CasADi__Matrix_double___arccosh+ :: Ptr DMatrix' -> IO (Ptr DMatrix')+casADi__Matrix_double___arccosh+ :: DMatrix -> IO DMatrix+casADi__Matrix_double___arccosh x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_double___arccosh x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++-- classy wrapper+{-|+>Operations defined in the standard namespace for unambigous access and Numpy+>compatibility.+-}+dmatrix_arccosh :: DMatrixClass a => a -> IO DMatrix+dmatrix_arccosh x = casADi__Matrix_double___arccosh (castDMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___arctanh" c_CasADi__Matrix_double___arctanh+ :: Ptr DMatrix' -> IO (Ptr DMatrix')+casADi__Matrix_double___arctanh+ :: DMatrix -> IO DMatrix+casADi__Matrix_double___arctanh x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_double___arctanh x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++-- classy wrapper+{-|+>Operations defined in the standard namespace for unambigous access and Numpy+>compatibility.+-}+dmatrix_arctanh :: DMatrixClass a => a -> IO DMatrix+dmatrix_arctanh x = casADi__Matrix_double___arctanh (castDMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___arctan2" c_CasADi__Matrix_double___arctan2+ :: Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')+casADi__Matrix_double___arctan2+ :: DMatrix -> DMatrix -> IO DMatrix+casADi__Matrix_double___arctan2 x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__Matrix_double___arctan2 x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++-- classy wrapper+{-|+>Operations defined in the standard namespace for unambigous access and Numpy+>compatibility.+-}+dmatrix_arctan2 :: DMatrixClass a => a -> DMatrix -> IO DMatrix+dmatrix_arctan2 x = casADi__Matrix_double___arctan2 (castDMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___log10" c_CasADi__Matrix_double___log10+ :: Ptr DMatrix' -> IO (Ptr DMatrix')+casADi__Matrix_double___log10+ :: DMatrix -> IO DMatrix+casADi__Matrix_double___log10 x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_double___log10 x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++-- classy wrapper+{-|+>Operations defined in the standard namespace for unambigous access and Numpy+>compatibility.+-}+dmatrix_log10 :: DMatrixClass a => a -> IO DMatrix+dmatrix_log10 x = casADi__Matrix_double___log10 (castDMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___printme" c_CasADi__Matrix_double___printme+ :: Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')+casADi__Matrix_double___printme+ :: DMatrix -> DMatrix -> IO DMatrix+casADi__Matrix_double___printme x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__Matrix_double___printme x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++-- classy wrapper+{-|+>Operations defined in the standard namespace for unambigous access and Numpy+>compatibility.+-}+dmatrix_printme :: DMatrixClass a => a -> DMatrix -> IO DMatrix+dmatrix_printme x = casADi__Matrix_double___printme (castDMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___logic_not" c_CasADi__Matrix_double___logic_not+ :: Ptr DMatrix' -> IO (Ptr DMatrix')+casADi__Matrix_double___logic_not+ :: DMatrix -> IO DMatrix+casADi__Matrix_double___logic_not x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_double___logic_not x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++-- classy wrapper+{-|+>Operations defined in the standard namespace for unambigous access and Numpy+>compatibility.+-}+dmatrix_logic_not :: DMatrixClass a => a -> IO DMatrix+dmatrix_logic_not x = casADi__Matrix_double___logic_not (castDMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___logic_and" c_CasADi__Matrix_double___logic_and+ :: Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')+casADi__Matrix_double___logic_and+ :: DMatrix -> DMatrix -> IO DMatrix+casADi__Matrix_double___logic_and x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__Matrix_double___logic_and x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++-- classy wrapper+{-|+>Operations defined in the standard namespace for unambigous access and Numpy+>compatibility.+-}+dmatrix_logic_and :: DMatrixClass a => a -> DMatrix -> IO DMatrix+dmatrix_logic_and x = casADi__Matrix_double___logic_and (castDMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___logic_or" c_CasADi__Matrix_double___logic_or+ :: Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')+casADi__Matrix_double___logic_or+ :: DMatrix -> DMatrix -> IO DMatrix+casADi__Matrix_double___logic_or x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__Matrix_double___logic_or x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++-- classy wrapper+{-|+>Operations defined in the standard namespace for unambigous access and Numpy+>compatibility.+-}+dmatrix_logic_or :: DMatrixClass a => a -> DMatrix -> IO DMatrix+dmatrix_logic_or x = casADi__Matrix_double___logic_or (castDMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___if_else_zero" c_CasADi__Matrix_double___if_else_zero+ :: Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')+casADi__Matrix_double___if_else_zero+ :: DMatrix -> DMatrix -> IO DMatrix+casADi__Matrix_double___if_else_zero x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__Matrix_double___if_else_zero x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++-- classy wrapper+{-|+>Operations defined in the standard namespace for unambigous access and Numpy+>compatibility.+-}+dmatrix_if_else_zero :: DMatrixClass a => a -> DMatrix -> IO DMatrix+dmatrix_if_else_zero x = casADi__Matrix_double___if_else_zero (castDMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___className" c_CasADi__Matrix_double___className+ :: IO (Ptr StdString')+casADi__Matrix_double___className+ :: IO String+casADi__Matrix_double___className =+ c_CasADi__Matrix_double___className >>= (newForeignPtr c_delete_std__string) >>= wrapReturn++-- classy wrapper+{-|+>Printing.+-}+dmatrix_className :: IO String+dmatrix_className = casADi__Matrix_double___className+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___printScalar_TIC" c_CasADi__Matrix_double___printScalar_TIC+ :: Ptr DMatrix' -> IO ()+casADi__Matrix_double___printScalar'+ :: DMatrix -> IO ()+casADi__Matrix_double___printScalar' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_double___printScalar_TIC x0' >>= wrapReturn++-- classy wrapper+dmatrix_printScalar' :: DMatrixClass a => a -> IO ()+dmatrix_printScalar' x = casADi__Matrix_double___printScalar' (castDMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___printVector_TIC" c_CasADi__Matrix_double___printVector_TIC+ :: Ptr DMatrix' -> IO ()+casADi__Matrix_double___printVector'+ :: DMatrix -> IO ()+casADi__Matrix_double___printVector' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_double___printVector_TIC x0' >>= wrapReturn++-- classy wrapper+dmatrix_printVector' :: DMatrixClass a => a -> IO ()+dmatrix_printVector' x = casADi__Matrix_double___printVector' (castDMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___printMatrix_TIC" c_CasADi__Matrix_double___printMatrix_TIC+ :: Ptr DMatrix' -> IO ()+casADi__Matrix_double___printMatrix'+ :: DMatrix -> IO ()+casADi__Matrix_double___printMatrix' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_double___printMatrix_TIC x0' >>= wrapReturn++-- classy wrapper+dmatrix_printMatrix' :: DMatrixClass a => a -> IO ()+dmatrix_printMatrix' x = casADi__Matrix_double___printMatrix' (castDMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___printSparse_TIC" c_CasADi__Matrix_double___printSparse_TIC+ :: Ptr DMatrix' -> IO ()+casADi__Matrix_double___printSparse'+ :: DMatrix -> IO ()+casADi__Matrix_double___printSparse' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_double___printSparse_TIC x0' >>= wrapReturn++-- classy wrapper+dmatrix_printSparse' :: DMatrixClass a => a -> IO ()+dmatrix_printSparse' x = casADi__Matrix_double___printSparse' (castDMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___printDense_TIC" c_CasADi__Matrix_double___printDense_TIC+ :: Ptr DMatrix' -> IO ()+casADi__Matrix_double___printDense'+ :: DMatrix -> IO ()+casADi__Matrix_double___printDense' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_double___printDense_TIC x0' >>= wrapReturn++-- classy wrapper+dmatrix_printDense' :: DMatrixClass a => a -> IO ()+dmatrix_printDense' x = casADi__Matrix_double___printDense' (castDMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___col" c_CasADi__Matrix_double___col+ :: Ptr DMatrix' -> CInt -> IO CInt+casADi__Matrix_double___col+ :: DMatrix -> Int -> IO Int+casADi__Matrix_double___col x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__Matrix_double___col x0' x1' >>= wrapReturn++-- classy wrapper+dmatrix_col :: DMatrixClass a => a -> Int -> IO Int+dmatrix_col x = casADi__Matrix_double___col (castDMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___rowind" c_CasADi__Matrix_double___rowind+ :: Ptr DMatrix' -> CInt -> IO CInt+casADi__Matrix_double___rowind+ :: DMatrix -> Int -> IO Int+casADi__Matrix_double___rowind x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__Matrix_double___rowind x0' x1' >>= wrapReturn++-- classy wrapper+dmatrix_rowind :: DMatrixClass a => a -> Int -> IO Int+dmatrix_rowind x = casADi__Matrix_double___rowind (castDMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___clear" c_CasADi__Matrix_double___clear+ :: Ptr DMatrix' -> IO ()+casADi__Matrix_double___clear+ :: DMatrix -> IO ()+casADi__Matrix_double___clear x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_double___clear x0' >>= wrapReturn++-- classy wrapper+dmatrix_clear :: DMatrixClass a => a -> IO ()+dmatrix_clear x = casADi__Matrix_double___clear (castDMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___resize" c_CasADi__Matrix_double___resize+ :: Ptr DMatrix' -> CInt -> CInt -> IO ()+casADi__Matrix_double___resize+ :: DMatrix -> Int -> Int -> IO ()+casADi__Matrix_double___resize x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__Matrix_double___resize x0' x1' x2' >>= wrapReturn++-- classy wrapper+dmatrix_resize :: DMatrixClass a => a -> Int -> Int -> IO ()+dmatrix_resize x = casADi__Matrix_double___resize (castDMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___reserve" c_CasADi__Matrix_double___reserve+ :: Ptr DMatrix' -> CInt -> IO ()+casADi__Matrix_double___reserve+ :: DMatrix -> Int -> IO ()+casADi__Matrix_double___reserve x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__Matrix_double___reserve x0' x1' >>= wrapReturn++-- classy wrapper+dmatrix_reserve :: DMatrixClass a => a -> Int -> IO ()+dmatrix_reserve x = casADi__Matrix_double___reserve (castDMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___reserve_TIC" c_CasADi__Matrix_double___reserve_TIC+ :: Ptr DMatrix' -> CInt -> CInt -> IO ()+casADi__Matrix_double___reserve'+ :: DMatrix -> Int -> Int -> IO ()+casADi__Matrix_double___reserve' x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__Matrix_double___reserve_TIC x0' x1' x2' >>= wrapReturn++-- classy wrapper+dmatrix_reserve' :: DMatrixClass a => a -> Int -> Int -> IO ()+dmatrix_reserve' x = casADi__Matrix_double___reserve' (castDMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___erase" c_CasADi__Matrix_double___erase+ :: Ptr DMatrix' -> Ptr (CppVec CInt) -> Ptr (CppVec CInt) -> IO ()+casADi__Matrix_double___erase+ :: DMatrix -> Vector Int -> Vector Int -> IO ()+casADi__Matrix_double___erase x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__Matrix_double___erase x0' x1' x2' >>= wrapReturn++-- classy wrapper+{-|+>Erase a submatrix Erase rows and/or columns of a matrix.+-}+dmatrix_erase :: DMatrixClass a => a -> Vector Int -> Vector Int -> IO ()+dmatrix_erase x = casADi__Matrix_double___erase (castDMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___remove" c_CasADi__Matrix_double___remove+ :: Ptr DMatrix' -> Ptr (CppVec CInt) -> Ptr (CppVec CInt) -> IO ()+casADi__Matrix_double___remove+ :: DMatrix -> Vector Int -> Vector Int -> IO ()+casADi__Matrix_double___remove x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__Matrix_double___remove x0' x1' x2' >>= wrapReturn++-- classy wrapper+{-|+>Remove rows or columns Rremove/delete rows and/or columns of a matrix.+-}+dmatrix_remove :: DMatrixClass a => a -> Vector Int -> Vector Int -> IO ()+dmatrix_remove x = casADi__Matrix_double___remove (castDMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___enlarge" c_CasADi__Matrix_double___enlarge+ :: Ptr DMatrix' -> CInt -> CInt -> Ptr (CppVec CInt) -> Ptr (CppVec CInt) -> IO ()+casADi__Matrix_double___enlarge+ :: DMatrix -> Int -> Int -> Vector Int -> Vector Int -> IO ()+casADi__Matrix_double___enlarge x0 x1 x2 x3 x4 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ withMarshal x3 $ \x3' ->+ withMarshal x4 $ \x4' ->+ c_CasADi__Matrix_double___enlarge x0' x1' x2' x3' x4' >>= wrapReturn++-- classy wrapper+{-|+>Enlarge matrix Make the matrix larger by inserting empty rows and columns,+>keeping the existing non-zeros.+-}+dmatrix_enlarge :: DMatrixClass a => a -> Int -> Int -> Vector Int -> Vector Int -> IO ()+dmatrix_enlarge x = casADi__Matrix_double___enlarge (castDMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___data" c_CasADi__Matrix_double___data+ :: Ptr DMatrix' -> IO (Ptr (CppVec CDouble))+casADi__Matrix_double___data+ :: DMatrix -> IO (Vector Double)+casADi__Matrix_double___data x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_double___data x0' >>= (newForeignPtr c_delete_std__vector_double_) >>= wrapReturn++-- classy wrapper+{-|+>> std::vector< T > & CasADi::Matrix< T >::data()+>------------------------------------------------------------------------+>+>Access the non-zero elements.+>+>> const std::vector< T > & CasADi::Matrix< T >::data() const +>------------------------------------------------------------------------+>+>Const access the non-zero elements.+-}+dmatrix_data :: DMatrixClass a => a -> IO (Vector Double)+dmatrix_data x = casADi__Matrix_double___data (castDMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___sparsityRef" c_CasADi__Matrix_double___sparsityRef+ :: Ptr DMatrix' -> IO (Ptr CRSSparsity')+casADi__Matrix_double___sparsityRef+ :: DMatrix -> IO CRSSparsity+casADi__Matrix_double___sparsityRef x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_double___sparsityRef x0' >>= (newForeignPtr c_delete_CasADi__CRSSparsity) >>= wrapReturn++-- classy wrapper+{-|+>Access the sparsity, make a copy if there are multiple references to it.+-}+dmatrix_sparsityRef :: DMatrixClass a => a -> IO CRSSparsity+dmatrix_sparsityRef x = casADi__Matrix_double___sparsityRef (castDMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___set" c_CasADi__Matrix_double___set+ :: Ptr DMatrix' -> CDouble -> CInt -> IO ()+casADi__Matrix_double___set+ :: DMatrix -> Double -> Sparsity -> IO ()+casADi__Matrix_double___set x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__Matrix_double___set x0' x1' x2' >>= wrapReturn++-- classy wrapper+{-|+>> void CasADi::Matrix< T >::set(T val, Sparsity sp=SPARSE)+>------------------------------------------------------------------------+>+>Set the non-zero elements, scalar.+>+>> void CasADi::Matrix< T >::set(const std::vector< T > &val, Sparsity sp=SPARSE)+>------------------------------------------------------------------------+>+>Set the non-zero elements, vector.+>+>> void CasADi::Matrix< T >::set(const Matrix< T > &val, Sparsity sp=SPARSE)+>------------------------------------------------------------------------+>+>Set the non-zero elements, Matrix.+>+>> void CasADi::Matrix< T >::set(const T *val, Sparsity sp=SPARSE)+>------------------------------------------------------------------------+>+>Legacy - use setArray instead.+-}+dmatrix_set :: DMatrixClass a => a -> Double -> Sparsity -> IO ()+dmatrix_set x = casADi__Matrix_double___set (castDMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___set_TIC" c_CasADi__Matrix_double___set_TIC+ :: Ptr DMatrix' -> CDouble -> IO ()+casADi__Matrix_double___set'+ :: DMatrix -> Double -> IO ()+casADi__Matrix_double___set' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__Matrix_double___set_TIC x0' x1' >>= wrapReturn++-- classy wrapper+dmatrix_set' :: DMatrixClass a => a -> Double -> IO ()+dmatrix_set' x = casADi__Matrix_double___set' (castDMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___get" c_CasADi__Matrix_double___get+ :: Ptr DMatrix' -> CDouble -> CInt -> IO ()+casADi__Matrix_double___get+ :: DMatrix -> Double -> Sparsity -> IO ()+casADi__Matrix_double___get x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__Matrix_double___get x0' x1' x2' >>= wrapReturn++-- classy wrapper+{-|+>> void CasADi::Matrix< T >::get(T &val, Sparsity sp=SPARSE) const +>------------------------------------------------------------------------+>+>Get the non-zero elements, scalar.+>+>> void CasADi::Matrix< T >::get(std::vector< T > &val, Sparsity sp=SPARSE) const +>------------------------------------------------------------------------+>+>Get the non-zero elements, vector.+>+>> void CasADi::Matrix< T >::get(Matrix< T > &val, Sparsity sp=SPARSE) const +>------------------------------------------------------------------------+>+>Get the non-zero elements, Matrix.+>+>> void CasADi::Matrix< T >::get(T *val, Sparsity sp=SPARSE) const +>------------------------------------------------------------------------+>+>Legacy - use getArray instead.+-}+dmatrix_get :: DMatrixClass a => a -> Double -> Sparsity -> IO ()+dmatrix_get x = casADi__Matrix_double___get (castDMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___get_TIC" c_CasADi__Matrix_double___get_TIC+ :: Ptr DMatrix' -> CDouble -> IO ()+casADi__Matrix_double___get'+ :: DMatrix -> Double -> IO ()+casADi__Matrix_double___get' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__Matrix_double___get_TIC x0' x1' >>= wrapReturn++-- classy wrapper+dmatrix_get' :: DMatrixClass a => a -> Double -> IO ()+dmatrix_get' x = casADi__Matrix_double___get' (castDMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___set_TIC_TIC" c_CasADi__Matrix_double___set_TIC_TIC+ :: Ptr DMatrix' -> Ptr (CppVec CDouble) -> CInt -> IO ()+casADi__Matrix_double___set''+ :: DMatrix -> Vector Double -> Sparsity -> IO ()+casADi__Matrix_double___set'' x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__Matrix_double___set_TIC_TIC x0' x1' x2' >>= wrapReturn++-- classy wrapper+dmatrix_set'' :: DMatrixClass a => a -> Vector Double -> Sparsity -> IO ()+dmatrix_set'' x = casADi__Matrix_double___set'' (castDMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___set_TIC_TIC_TIC" c_CasADi__Matrix_double___set_TIC_TIC_TIC+ :: Ptr DMatrix' -> Ptr (CppVec CDouble) -> IO ()+casADi__Matrix_double___set'''+ :: DMatrix -> Vector Double -> IO ()+casADi__Matrix_double___set''' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__Matrix_double___set_TIC_TIC_TIC x0' x1' >>= wrapReturn++-- classy wrapper+dmatrix_set''' :: DMatrixClass a => a -> Vector Double -> IO ()+dmatrix_set''' x = casADi__Matrix_double___set''' (castDMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___get_TIC_TIC" c_CasADi__Matrix_double___get_TIC_TIC+ :: Ptr DMatrix' -> Ptr (CppVec CDouble) -> CInt -> IO ()+casADi__Matrix_double___get''+ :: DMatrix -> Vector Double -> Sparsity -> IO ()+casADi__Matrix_double___get'' x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__Matrix_double___get_TIC_TIC x0' x1' x2' >>= wrapReturn++-- classy wrapper+dmatrix_get'' :: DMatrixClass a => a -> Vector Double -> Sparsity -> IO ()+dmatrix_get'' x = casADi__Matrix_double___get'' (castDMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___get_TIC_TIC_TIC" c_CasADi__Matrix_double___get_TIC_TIC_TIC+ :: Ptr DMatrix' -> Ptr (CppVec CDouble) -> IO ()+casADi__Matrix_double___get'''+ :: DMatrix -> Vector Double -> IO ()+casADi__Matrix_double___get''' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__Matrix_double___get_TIC_TIC_TIC x0' x1' >>= wrapReturn++-- classy wrapper+dmatrix_get''' :: DMatrixClass a => a -> Vector Double -> IO ()+dmatrix_get''' x = casADi__Matrix_double___get''' (castDMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___set_TIC_TIC_TIC_TIC" c_CasADi__Matrix_double___set_TIC_TIC_TIC_TIC+ :: Ptr DMatrix' -> Ptr DMatrix' -> CInt -> IO ()+casADi__Matrix_double___set''''+ :: DMatrix -> DMatrix -> Sparsity -> IO ()+casADi__Matrix_double___set'''' x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__Matrix_double___set_TIC_TIC_TIC_TIC x0' x1' x2' >>= wrapReturn++-- classy wrapper+dmatrix_set'''' :: DMatrixClass a => a -> DMatrix -> Sparsity -> IO ()+dmatrix_set'''' x = casADi__Matrix_double___set'''' (castDMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___set_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_double___set_TIC_TIC_TIC_TIC_TIC+ :: Ptr DMatrix' -> Ptr DMatrix' -> IO ()+casADi__Matrix_double___set'''''+ :: DMatrix -> DMatrix -> IO ()+casADi__Matrix_double___set''''' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__Matrix_double___set_TIC_TIC_TIC_TIC_TIC x0' x1' >>= wrapReturn++-- classy wrapper+dmatrix_set''''' :: DMatrixClass a => a -> DMatrix -> IO ()+dmatrix_set''''' x = casADi__Matrix_double___set''''' (castDMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___get_TIC_TIC_TIC_TIC" c_CasADi__Matrix_double___get_TIC_TIC_TIC_TIC+ :: Ptr DMatrix' -> Ptr DMatrix' -> CInt -> IO ()+casADi__Matrix_double___get''''+ :: DMatrix -> DMatrix -> Sparsity -> IO ()+casADi__Matrix_double___get'''' x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__Matrix_double___get_TIC_TIC_TIC_TIC x0' x1' x2' >>= wrapReturn++-- classy wrapper+dmatrix_get'''' :: DMatrixClass a => a -> DMatrix -> Sparsity -> IO ()+dmatrix_get'''' x = casADi__Matrix_double___get'''' (castDMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___get_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_double___get_TIC_TIC_TIC_TIC_TIC+ :: Ptr DMatrix' -> Ptr DMatrix' -> IO ()+casADi__Matrix_double___get'''''+ :: DMatrix -> DMatrix -> IO ()+casADi__Matrix_double___get''''' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__Matrix_double___get_TIC_TIC_TIC_TIC_TIC x0' x1' >>= wrapReturn++-- classy wrapper+dmatrix_get''''' :: DMatrixClass a => a -> DMatrix -> IO ()+dmatrix_get''''' x = casADi__Matrix_double___get''''' (castDMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___sparse" c_CasADi__Matrix_double___sparse+ :: CInt -> CInt -> IO (Ptr DMatrix')+casADi__Matrix_double___sparse+ :: Int -> Int -> IO DMatrix+casADi__Matrix_double___sparse x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__Matrix_double___sparse x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++-- classy wrapper+{-|+>> Matrix< T > CasADi::Matrix< T >::sparse(int nrow, int ncol=1)+>+>> Matrix< T > CasADi::Matrix< T >::sparse(const std::pair< int, int > &nm)+>------------------------------------------------------------------------+>+>create a sparse matrix with all zeros+>+>> Matrix< T > CasADi::Matrix< T >::sparse(const std::vector< int > &row, const std::vector< int > &col, const std::vector< T > &d, int n, int m)+>+>> Matrix< T > CasADi::Matrix< T >::sparse(const std::vector< int > &row, const std::vector< int > &col, const std::vector< T > &d, const std::pair< int, int > &nm)+>------------------------------------------------------------------------+>+>Construct a sparse matrix from triplet form.+-}+dmatrix_sparse :: Int -> Int -> IO DMatrix+dmatrix_sparse = casADi__Matrix_double___sparse+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___sparse_TIC" c_CasADi__Matrix_double___sparse_TIC+ :: CInt -> IO (Ptr DMatrix')+casADi__Matrix_double___sparse'+ :: Int -> IO DMatrix+casADi__Matrix_double___sparse' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_double___sparse_TIC x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++-- classy wrapper+dmatrix_sparse' :: Int -> IO DMatrix+dmatrix_sparse' = casADi__Matrix_double___sparse'+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___sparse_TIC_TIC" c_CasADi__Matrix_double___sparse_TIC_TIC+ :: Ptr (CppVec CInt) -> Ptr (CppVec CInt) -> Ptr (CppVec CDouble) -> IO (Ptr DMatrix')+casADi__Matrix_double___sparse''+ :: Vector Int -> Vector Int -> Vector Double -> IO DMatrix+casADi__Matrix_double___sparse'' x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__Matrix_double___sparse_TIC_TIC x0' x1' x2' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++-- classy wrapper+dmatrix_sparse'' :: Vector Int -> Vector Int -> Vector Double -> IO DMatrix+dmatrix_sparse'' = casADi__Matrix_double___sparse''+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___sparse_TIC_TIC_TIC" c_CasADi__Matrix_double___sparse_TIC_TIC_TIC+ :: Ptr (CppVec CInt) -> Ptr (CppVec CInt) -> Ptr (CppVec CDouble) -> CInt -> CInt -> IO (Ptr DMatrix')+casADi__Matrix_double___sparse'''+ :: Vector Int -> Vector Int -> Vector Double -> Int -> Int -> IO DMatrix+casADi__Matrix_double___sparse''' x0 x1 x2 x3 x4 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ withMarshal x3 $ \x3' ->+ withMarshal x4 $ \x4' ->+ c_CasADi__Matrix_double___sparse_TIC_TIC_TIC x0' x1' x2' x3' x4' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++-- classy wrapper+dmatrix_sparse''' :: Vector Int -> Vector Int -> Vector Double -> Int -> Int -> IO DMatrix+dmatrix_sparse''' = casADi__Matrix_double___sparse'''+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___zeros" c_CasADi__Matrix_double___zeros+ :: Ptr CRSSparsity' -> IO (Ptr DMatrix')+casADi__Matrix_double___zeros+ :: CRSSparsity -> IO DMatrix+casADi__Matrix_double___zeros x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_double___zeros x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++-- classy wrapper+{-|+>create a dense matrix with all zeros+-}+dmatrix_zeros :: CRSSparsity -> IO DMatrix+dmatrix_zeros = casADi__Matrix_double___zeros+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___zeros_TIC" c_CasADi__Matrix_double___zeros_TIC+ :: CInt -> CInt -> IO (Ptr DMatrix')+casADi__Matrix_double___zeros'+ :: Int -> Int -> IO DMatrix+casADi__Matrix_double___zeros' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__Matrix_double___zeros_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++-- classy wrapper+dmatrix_zeros' :: Int -> Int -> IO DMatrix+dmatrix_zeros' = casADi__Matrix_double___zeros'+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___zeros_TIC_TIC" c_CasADi__Matrix_double___zeros_TIC_TIC+ :: CInt -> IO (Ptr DMatrix')+casADi__Matrix_double___zeros''+ :: Int -> IO DMatrix+casADi__Matrix_double___zeros'' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_double___zeros_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++-- classy wrapper+dmatrix_zeros'' :: Int -> IO DMatrix+dmatrix_zeros'' = casADi__Matrix_double___zeros''+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___ones" c_CasADi__Matrix_double___ones+ :: Ptr CRSSparsity' -> IO (Ptr DMatrix')+casADi__Matrix_double___ones+ :: CRSSparsity -> IO DMatrix+casADi__Matrix_double___ones x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_double___ones x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++-- classy wrapper+{-|+>create a matrix with all ones+-}+dmatrix_ones :: CRSSparsity -> IO DMatrix+dmatrix_ones = casADi__Matrix_double___ones+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___ones_TIC" c_CasADi__Matrix_double___ones_TIC+ :: CInt -> CInt -> IO (Ptr DMatrix')+casADi__Matrix_double___ones'+ :: Int -> Int -> IO DMatrix+casADi__Matrix_double___ones' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__Matrix_double___ones_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++-- classy wrapper+dmatrix_ones' :: Int -> Int -> IO DMatrix+dmatrix_ones' = casADi__Matrix_double___ones'+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___ones_TIC_TIC" c_CasADi__Matrix_double___ones_TIC_TIC+ :: CInt -> IO (Ptr DMatrix')+casADi__Matrix_double___ones''+ :: Int -> IO DMatrix+casADi__Matrix_double___ones'' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_double___ones_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++-- classy wrapper+dmatrix_ones'' :: Int -> IO DMatrix+dmatrix_ones'' = casADi__Matrix_double___ones''+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___inf" c_CasADi__Matrix_double___inf+ :: Ptr CRSSparsity' -> IO (Ptr DMatrix')+casADi__Matrix_double___inf+ :: CRSSparsity -> IO DMatrix+casADi__Matrix_double___inf x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_double___inf x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++-- classy wrapper+{-|+>create a matrix with all inf+-}+dmatrix_inf :: CRSSparsity -> IO DMatrix+dmatrix_inf = casADi__Matrix_double___inf+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___inf_TIC" c_CasADi__Matrix_double___inf_TIC+ :: CInt -> CInt -> IO (Ptr DMatrix')+casADi__Matrix_double___inf'+ :: Int -> Int -> IO DMatrix+casADi__Matrix_double___inf' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__Matrix_double___inf_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++-- classy wrapper+dmatrix_inf' :: Int -> Int -> IO DMatrix+dmatrix_inf' = casADi__Matrix_double___inf'+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___inf_TIC_TIC" c_CasADi__Matrix_double___inf_TIC_TIC+ :: CInt -> IO (Ptr DMatrix')+casADi__Matrix_double___inf''+ :: Int -> IO DMatrix+casADi__Matrix_double___inf'' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_double___inf_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++-- classy wrapper+dmatrix_inf'' :: Int -> IO DMatrix+dmatrix_inf'' = casADi__Matrix_double___inf''+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___inf_TIC_TIC_TIC" c_CasADi__Matrix_double___inf_TIC_TIC_TIC+ :: IO (Ptr DMatrix')+casADi__Matrix_double___inf'''+ :: IO DMatrix+casADi__Matrix_double___inf''' =+ c_CasADi__Matrix_double___inf_TIC_TIC_TIC >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++-- classy wrapper+dmatrix_inf''' :: IO DMatrix+dmatrix_inf''' = casADi__Matrix_double___inf'''+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___nan" c_CasADi__Matrix_double___nan+ :: Ptr CRSSparsity' -> IO (Ptr DMatrix')+casADi__Matrix_double___nan+ :: CRSSparsity -> IO DMatrix+casADi__Matrix_double___nan x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_double___nan x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++-- classy wrapper+{-|+>create a matrix with all nan+-}+dmatrix_nan :: CRSSparsity -> IO DMatrix+dmatrix_nan = casADi__Matrix_double___nan+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___nan_TIC" c_CasADi__Matrix_double___nan_TIC+ :: CInt -> CInt -> IO (Ptr DMatrix')+casADi__Matrix_double___nan'+ :: Int -> Int -> IO DMatrix+casADi__Matrix_double___nan' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__Matrix_double___nan_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++-- classy wrapper+dmatrix_nan' :: Int -> Int -> IO DMatrix+dmatrix_nan' = casADi__Matrix_double___nan'+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___nan_TIC_TIC" c_CasADi__Matrix_double___nan_TIC_TIC+ :: CInt -> IO (Ptr DMatrix')+casADi__Matrix_double___nan''+ :: Int -> IO DMatrix+casADi__Matrix_double___nan'' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_double___nan_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++-- classy wrapper+dmatrix_nan'' :: Int -> IO DMatrix+dmatrix_nan'' = casADi__Matrix_double___nan''+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___nan_TIC_TIC_TIC" c_CasADi__Matrix_double___nan_TIC_TIC_TIC+ :: IO (Ptr DMatrix')+casADi__Matrix_double___nan'''+ :: IO DMatrix+casADi__Matrix_double___nan''' =+ c_CasADi__Matrix_double___nan_TIC_TIC_TIC >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++-- classy wrapper+dmatrix_nan''' :: IO DMatrix+dmatrix_nan''' = casADi__Matrix_double___nan'''+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___repmat" c_CasADi__Matrix_double___repmat+ :: Ptr DMatrix' -> CInt -> CInt -> IO (Ptr DMatrix')+casADi__Matrix_double___repmat+ :: DMatrix -> Int -> Int -> IO DMatrix+casADi__Matrix_double___repmat x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__Matrix_double___repmat x0' x1' x2' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++-- classy wrapper+{-|+>create a matrix by repeating an existing matrix+-}+dmatrix_repmat :: DMatrix -> Int -> Int -> IO DMatrix+dmatrix_repmat = casADi__Matrix_double___repmat+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___repmat_TIC" c_CasADi__Matrix_double___repmat_TIC+ :: Ptr DMatrix' -> CInt -> IO (Ptr DMatrix')+casADi__Matrix_double___repmat'+ :: DMatrix -> Int -> IO DMatrix+casADi__Matrix_double___repmat' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__Matrix_double___repmat_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++-- classy wrapper+dmatrix_repmat' :: DMatrix -> Int -> IO DMatrix+dmatrix_repmat' = casADi__Matrix_double___repmat'+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___eye" c_CasADi__Matrix_double___eye+ :: CInt -> IO (Ptr DMatrix')+casADi__Matrix_double___eye+ :: Int -> IO DMatrix+casADi__Matrix_double___eye x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_double___eye x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++-- classy wrapper+dmatrix_eye :: Int -> IO DMatrix+dmatrix_eye = casADi__Matrix_double___eye+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___isNull" c_CasADi__Matrix_double___isNull+ :: Ptr DMatrix' -> IO (Ptr CppBool')+casADi__Matrix_double___isNull+ :: DMatrix -> IO Bool+casADi__Matrix_double___isNull x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_double___isNull x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++-- classy wrapper+{-|+>The following function is used to ensure similarity to MX, which is+>reference counted.+-}+dmatrix_isNull :: DMatrixClass a => a -> IO Bool+dmatrix_isNull x = casADi__Matrix_double___isNull (castDMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___setPrecision" c_CasADi__Matrix_double___setPrecision+ :: CInt -> IO ()+casADi__Matrix_double___setPrecision+ :: Int -> IO ()+casADi__Matrix_double___setPrecision x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_double___setPrecision x0' >>= wrapReturn++-- classy wrapper+{-|+>Set the 'precision, width & scientific' used in printing and serializing to+>streams.+-}+dmatrix_setPrecision :: Int -> IO ()+dmatrix_setPrecision = casADi__Matrix_double___setPrecision+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___setWidth" c_CasADi__Matrix_double___setWidth+ :: CInt -> IO ()+casADi__Matrix_double___setWidth+ :: Int -> IO ()+casADi__Matrix_double___setWidth x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_double___setWidth x0' >>= wrapReturn++-- classy wrapper+{-|+>Set the 'precision, width & scientific' used in printing and serializing to+>streams.+-}+dmatrix_setWidth :: Int -> IO ()+dmatrix_setWidth = casADi__Matrix_double___setWidth+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___setScientific" c_CasADi__Matrix_double___setScientific+ :: Ptr CppBool' -> IO ()+casADi__Matrix_double___setScientific+ :: Bool -> IO ()+casADi__Matrix_double___setScientific x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_double___setScientific x0' >>= wrapReturn++-- classy wrapper+{-|+>Set the 'precision, width & scientific' used in printing and serializing to+>streams.+-}+dmatrix_setScientific :: Bool -> IO ()+dmatrix_setScientific = casADi__Matrix_double___setScientific+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___DMatrix" c_CasADi__Matrix_double___DMatrix+ :: IO (Ptr DMatrix')+casADi__Matrix_double___DMatrix+ :: IO DMatrix+casADi__Matrix_double___DMatrix =+ c_CasADi__Matrix_double___DMatrix >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++-- classy wrapper+{-|+>> CasADi::Matrix< T >::Matrix()+>------------------------------------------------------------------------+>+>constructors+>+>empty 0-by-0 matrix constructor+>+>> CasADi::Matrix< T >::Matrix(const Matrix< T > &m)+>------------------------------------------------------------------------+>+>Copy constructor.+>+>> CasADi::Matrix< T >::Matrix(int n, int m)+>------------------------------------------------------------------------+>+>empty n-by-m matrix constructor+>+>> CasADi::Matrix< T >::Matrix(int n, int m, const T &val)+>------------------------------------------------------------------------+>+>dense n-by-m matrix filled with val constructor+>+>> CasADi::Matrix< T >::Matrix(int n, int m, const std::vector< int > &col, const std::vector< int > &rowind, const std::vector< T > &d=std::vector< T >())+>------------------------------------------------------------------------+>+>sparse n-by-m matrix filled with given sparsity+>+>> CasADi::Matrix< T >::Matrix(const std::vector< std::vector< T > > &m)+>------------------------------------------------------------------------+>+>dense matrix constructor with data given as vector of vectors+>+>> CasADi::Matrix< T >::Matrix(const CRSSparsity &sparsity, const T &val=0)+>------------------------------------------------------------------------+>+>sparse matrix with a given sparsity+>+>> CasADi::Matrix< T >::Matrix(const CRSSparsity &sparsity, const std::vector< T > &d)+>------------------------------------------------------------------------+>+>sparse matrix with a given sparsity and non-zero elements.+>+>> CasADi::Matrix< T >::Matrix(double val)+>------------------------------------------------------------------------+>+>This constructor enables implicit type conversion from a numeric type.+>+>> CasADi::Matrix< T >::Matrix(const std::vector< T > &x)+>------------------------------------------------------------------------+>+>Construct from a vector.+>+>Thanks to implicit conversion, you can pretend that Matrix(const SX& x);+>exists. Note: above remark applies only to C++, not python or octave+>interfaces+>+>> CasADi::Matrix< T >::Matrix(const std::vector< T > &x, int n, int m)+>------------------------------------------------------------------------+>+>Construct dense matrix from a vector with the elements in column major+>ordering.+>+>> CasADi::Matrix< T >::Matrix(const Matrix< A > &x)+>------------------------------------------------------------------------+>+>Create a matrix from a matrix with a different type of matrix entries+>(assuming that the scalar conversion is valid)+>+>> CasADi::Matrix< T >::Matrix(const std::vector< A > &x)+>------------------------------------------------------------------------+>+>Create an expression from an stl vector.+>+>> CasADi::Matrix< T >::Matrix(const std::vector< A > &x, int n, int m)+>------------------------------------------------------------------------+>+>Create a non-vector expression from an stl vector.+-}+dmatrix :: IO DMatrix+dmatrix = casADi__Matrix_double___DMatrix+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___DMatrix_TIC" c_CasADi__Matrix_double___DMatrix_TIC+ :: Ptr DMatrix' -> IO (Ptr DMatrix')+casADi__Matrix_double___DMatrix'+ :: DMatrix -> IO DMatrix+casADi__Matrix_double___DMatrix' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_double___DMatrix_TIC x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++-- classy wrapper+dmatrix' :: DMatrix -> IO DMatrix+dmatrix' = casADi__Matrix_double___DMatrix'+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___DMatrix_TIC_TIC" c_CasADi__Matrix_double___DMatrix_TIC_TIC+ :: CInt -> CInt -> IO (Ptr DMatrix')+casADi__Matrix_double___DMatrix''+ :: Int -> Int -> IO DMatrix+casADi__Matrix_double___DMatrix'' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__Matrix_double___DMatrix_TIC_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++-- classy wrapper+dmatrix'' :: Int -> Int -> IO DMatrix+dmatrix'' = casADi__Matrix_double___DMatrix''+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___DMatrix_TIC_TIC_TIC" c_CasADi__Matrix_double___DMatrix_TIC_TIC_TIC+ :: CInt -> CInt -> CDouble -> IO (Ptr DMatrix')+casADi__Matrix_double___DMatrix'''+ :: Int -> Int -> Double -> IO DMatrix+casADi__Matrix_double___DMatrix''' x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__Matrix_double___DMatrix_TIC_TIC_TIC x0' x1' x2' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++-- classy wrapper+dmatrix''' :: Int -> Int -> Double -> IO DMatrix+dmatrix''' = casADi__Matrix_double___DMatrix'''+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC" c_CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC+ :: CInt -> CInt -> Ptr (CppVec CInt) -> Ptr (CppVec CInt) -> Ptr (CppVec CDouble) -> IO (Ptr DMatrix')+casADi__Matrix_double___DMatrix''''+ :: Int -> Int -> Vector Int -> Vector Int -> Vector Double -> IO DMatrix+casADi__Matrix_double___DMatrix'''' x0 x1 x2 x3 x4 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ withMarshal x3 $ \x3' ->+ withMarshal x4 $ \x4' ->+ c_CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC x0' x1' x2' x3' x4' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++-- classy wrapper+dmatrix'''' :: Int -> Int -> Vector Int -> Vector Int -> Vector Double -> IO DMatrix+dmatrix'''' = casADi__Matrix_double___DMatrix''''+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC+ :: CInt -> CInt -> Ptr (CppVec CInt) -> Ptr (CppVec CInt) -> IO (Ptr DMatrix')+casADi__Matrix_double___DMatrix'''''+ :: Int -> Int -> Vector Int -> Vector Int -> IO DMatrix+casADi__Matrix_double___DMatrix''''' x0 x1 x2 x3 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ withMarshal x3 $ \x3' ->+ c_CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC x0' x1' x2' x3' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++-- classy wrapper+dmatrix''''' :: Int -> Int -> Vector Int -> Vector Int -> IO DMatrix+dmatrix''''' = casADi__Matrix_double___DMatrix'''''+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC+ :: Ptr (CppVecVec CDouble) -> IO (Ptr DMatrix')+casADi__Matrix_double___DMatrix''''''+ :: Vector (Vector Double) -> IO DMatrix+casADi__Matrix_double___DMatrix'''''' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++-- classy wrapper+dmatrix'''''' :: Vector (Vector Double) -> IO DMatrix+dmatrix'''''' = casADi__Matrix_double___DMatrix''''''+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC+ :: Ptr CRSSparsity' -> CDouble -> IO (Ptr DMatrix')+casADi__Matrix_double___DMatrix'''''''+ :: CRSSparsity -> Double -> IO DMatrix+casADi__Matrix_double___DMatrix''''''' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++-- classy wrapper+dmatrix''''''' :: CRSSparsity -> Double -> IO DMatrix+dmatrix''''''' = casADi__Matrix_double___DMatrix'''''''+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC+ :: Ptr CRSSparsity' -> IO (Ptr DMatrix')+casADi__Matrix_double___DMatrix''''''''+ :: CRSSparsity -> IO DMatrix+casADi__Matrix_double___DMatrix'''''''' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++-- classy wrapper+dmatrix'''''''' :: CRSSparsity -> IO DMatrix+dmatrix'''''''' = casADi__Matrix_double___DMatrix''''''''+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC+ :: Ptr CRSSparsity' -> Ptr (CppVec CDouble) -> IO (Ptr DMatrix')+casADi__Matrix_double___DMatrix'''''''''+ :: CRSSparsity -> Vector Double -> IO DMatrix+casADi__Matrix_double___DMatrix''''''''' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++-- classy wrapper+dmatrix''''''''' :: CRSSparsity -> Vector Double -> IO DMatrix+dmatrix''''''''' = casADi__Matrix_double___DMatrix'''''''''+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC+ :: CDouble -> IO (Ptr DMatrix')+casADi__Matrix_double___DMatrix''''''''''+ :: Double -> IO DMatrix+casADi__Matrix_double___DMatrix'''''''''' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++-- classy wrapper+dmatrix'''''''''' :: Double -> IO DMatrix+dmatrix'''''''''' = casADi__Matrix_double___DMatrix''''''''''+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC+ :: Ptr (CppVec CDouble) -> IO (Ptr DMatrix')+casADi__Matrix_double___DMatrix'''''''''''+ :: Vector Double -> IO DMatrix+casADi__Matrix_double___DMatrix''''''''''' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++-- classy wrapper+dmatrix''''''''''' :: Vector Double -> IO DMatrix+dmatrix''''''''''' = casADi__Matrix_double___DMatrix'''''''''''+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC+ :: Ptr (CppVec CDouble) -> CInt -> CInt -> IO (Ptr DMatrix')+casADi__Matrix_double___DMatrix''''''''''''+ :: Vector Double -> Int -> Int -> IO DMatrix+casADi__Matrix_double___DMatrix'''''''''''' x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++-- classy wrapper+dmatrix'''''''''''' :: Vector Double -> Int -> Int -> IO DMatrix+dmatrix'''''''''''' = casADi__Matrix_double___DMatrix''''''''''''+
+ Casadi/Wrappers/Classes/ExternalFunction.hs view
@@ -0,0 +1,93 @@+{-# OPTIONS_GHC -Wall #-}+{-# OPTIONS_GHC -fno-warn-unused-imports #-}+{-# OPTIONS_GHC -fno-warn-orphans #-}+{-# Language ForeignFunctionInterface #-}+{-# Language FlexibleInstances #-}+{-# Language MultiParamTypeClasses #-}++module Casadi.Wrappers.Classes.ExternalFunction+ (+ ExternalFunction,+ ExternalFunctionClass(..),+ externalFunction,+ externalFunction',+ externalFunction_checkNode,+ ) where+++import Prelude hiding ( Functor )++import Data.Vector ( Vector )+import Foreign.C.Types+import Foreign.Ptr ( Ptr )+import Foreign.ForeignPtr ( newForeignPtr )+import System.IO.Unsafe ( unsafePerformIO ) -- for show instances++import Casadi.Wrappers.Classes.PrintableObject+import Casadi.Wrappers.ForeignToolsInstances ( )+import Casadi.Wrappers.Deleters+import Casadi.Wrappers.Data+import Casadi.Wrappers.Enums+import Casadi.MarshalTypes ( CppVec, CppVecVec, CppVecVecVec,+ StdString', CppBool' ) -- StdOstream'+import Casadi.Marshal ( CornerCase(..), Marshal(..) )+import Casadi.WrapReturn ( WrapReturn(..) )++instance Show ExternalFunction where+ show = unsafePerformIO . printableObject_getDescription+-- direct wrapper+foreign import ccall unsafe "CasADi__ExternalFunction__checkNode" c_CasADi__ExternalFunction__checkNode+ :: Ptr ExternalFunction' -> IO (Ptr CppBool')+casADi__ExternalFunction__checkNode+ :: ExternalFunction -> IO Bool+casADi__ExternalFunction__checkNode x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__ExternalFunction__checkNode x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++-- classy wrapper+{-|+>Check if the pointer points towards a valid object.+-}+externalFunction_checkNode :: ExternalFunctionClass a => a -> IO Bool+externalFunction_checkNode x = casADi__ExternalFunction__checkNode (castExternalFunction x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__ExternalFunction__ExternalFunction" c_CasADi__ExternalFunction__ExternalFunction+ :: IO (Ptr ExternalFunction')+casADi__ExternalFunction__ExternalFunction+ :: IO ExternalFunction+casADi__ExternalFunction__ExternalFunction =+ c_CasADi__ExternalFunction__ExternalFunction >>= (newForeignPtr c_delete_CasADi__ExternalFunction) >>= wrapReturn++-- classy wrapper+{-|+>> CasADi::ExternalFunction::ExternalFunction()+>------------------------------------------------------------------------+>+>CONSTRUCTORS:+>+>default constructor+>+>> CasADi::ExternalFunction::ExternalFunction(const std::string &bin_name)+>------------------------------------------------------------------------+>+>Create an empty function.+-}+externalFunction :: IO ExternalFunction+externalFunction = casADi__ExternalFunction__ExternalFunction+++-- direct wrapper+foreign import ccall unsafe "CasADi__ExternalFunction__ExternalFunction_TIC" c_CasADi__ExternalFunction__ExternalFunction_TIC+ :: Ptr StdString' -> IO (Ptr ExternalFunction')+casADi__ExternalFunction__ExternalFunction'+ :: String -> IO ExternalFunction+casADi__ExternalFunction__ExternalFunction' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__ExternalFunction__ExternalFunction_TIC x0' >>= (newForeignPtr c_delete_CasADi__ExternalFunction) >>= wrapReturn++-- classy wrapper+externalFunction' :: String -> IO ExternalFunction+externalFunction' = casADi__ExternalFunction__ExternalFunction'+
+ Casadi/Wrappers/Classes/FX.hs view
@@ -0,0 +1,569 @@+{-# OPTIONS_GHC -Wall #-}+{-# OPTIONS_GHC -fno-warn-unused-imports #-}+{-# OPTIONS_GHC -fno-warn-orphans #-}+{-# Language ForeignFunctionInterface #-}+{-# Language FlexibleInstances #-}+{-# Language MultiParamTypeClasses #-}++module Casadi.Wrappers.Classes.FX+ (+ FX,+ FXClass(..),+ fx_addMonitor,+ fx_call,+ fx_call'',+ fx_checkInputs,+ fx_checkNode,+ fx_evalMX,+ fx_evalSX,+ fx_evaluate,+ fx_fullJacobian,+ fx_generateCode,+ fx_getInputScheme,+ fx_getOutputScheme,+ fx_getStat,+ fx_gradient,+ fx_hessian,+ fx_inputScheme,+ fx_jacobian,+ fx_outputScheme,+ fx_removeMonitor,+ fx_setInputScheme,+ fx_setOutputScheme,+ fx_solve,+ fx_symbolicInput,+ fx_symbolicInputSX,+ ) where+++import Prelude hiding ( Functor )++import Data.Vector ( Vector )+import Foreign.C.Types+import Foreign.Ptr ( Ptr )+import Foreign.ForeignPtr ( newForeignPtr )+import System.IO.Unsafe ( unsafePerformIO ) -- for show instances++import Casadi.Wrappers.Classes.PrintableObject+import Casadi.Wrappers.ForeignToolsInstances ( )+import Casadi.Wrappers.Deleters+import Casadi.Wrappers.Data+import Casadi.Wrappers.Enums+import Casadi.MarshalTypes ( CppVec, CppVecVec, CppVecVecVec,+ StdString', CppBool' ) -- StdOstream'+import Casadi.Marshal ( CornerCase(..), Marshal(..) )+import Casadi.WrapReturn ( WrapReturn(..) )++instance Show FX where+ show = unsafePerformIO . printableObject_getDescription+-- direct wrapper+foreign import ccall unsafe "CasADi__FX__inputScheme" c_CasADi__FX__inputScheme+ :: Ptr FX' -> IO (Ptr IOScheme')+casADi__FX__inputScheme+ :: FX -> IO IOScheme+casADi__FX__inputScheme x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__FX__inputScheme x0' >>= (newForeignPtr c_delete_CasADi__IOScheme) >>= wrapReturn++-- classy wrapper+{-|+>Access input/output scheme.+-}+fx_inputScheme :: FXClass a => a -> IO IOScheme+fx_inputScheme x = casADi__FX__inputScheme (castFX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__FX__outputScheme" c_CasADi__FX__outputScheme+ :: Ptr FX' -> IO (Ptr IOScheme')+casADi__FX__outputScheme+ :: FX -> IO IOScheme+casADi__FX__outputScheme x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__FX__outputScheme x0' >>= (newForeignPtr c_delete_CasADi__IOScheme) >>= wrapReturn++-- classy wrapper+{-|+>Access input/output scheme.+-}+fx_outputScheme :: FXClass a => a -> IO IOScheme+fx_outputScheme x = casADi__FX__outputScheme (castFX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__FX__setInputScheme" c_CasADi__FX__setInputScheme+ :: Ptr FX' -> Ptr IOScheme' -> IO ()+casADi__FX__setInputScheme+ :: FX -> IOScheme -> IO ()+casADi__FX__setInputScheme x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__FX__setInputScheme x0' x1' >>= wrapReturn++-- classy wrapper+{-|+>Set input scheme.+-}+fx_setInputScheme :: FXClass a => a -> IOScheme -> IO ()+fx_setInputScheme x = casADi__FX__setInputScheme (castFX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__FX__setOutputScheme" c_CasADi__FX__setOutputScheme+ :: Ptr FX' -> Ptr IOScheme' -> IO ()+casADi__FX__setOutputScheme+ :: FX -> IOScheme -> IO ()+casADi__FX__setOutputScheme x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__FX__setOutputScheme x0' x1' >>= wrapReturn++-- classy wrapper+{-|+>Set output scheme.+-}+fx_setOutputScheme :: FXClass a => a -> IOScheme -> IO ()+fx_setOutputScheme x = casADi__FX__setOutputScheme (castFX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__FX__getInputScheme" c_CasADi__FX__getInputScheme+ :: Ptr FX' -> IO (Ptr IOScheme')+casADi__FX__getInputScheme+ :: FX -> IO IOScheme+casADi__FX__getInputScheme x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__FX__getInputScheme x0' >>= (newForeignPtr c_delete_CasADi__IOScheme) >>= wrapReturn++-- classy wrapper+{-|+>Get input scheme.+-}+fx_getInputScheme :: FXClass a => a -> IO IOScheme+fx_getInputScheme x = casADi__FX__getInputScheme (castFX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__FX__getOutputScheme" c_CasADi__FX__getOutputScheme+ :: Ptr FX' -> IO (Ptr IOScheme')+casADi__FX__getOutputScheme+ :: FX -> IO IOScheme+casADi__FX__getOutputScheme x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__FX__getOutputScheme x0' >>= (newForeignPtr c_delete_CasADi__IOScheme) >>= wrapReturn++-- classy wrapper+{-|+>Get output scheme.+-}+fx_getOutputScheme :: FXClass a => a -> IO IOScheme+fx_getOutputScheme x = casADi__FX__getOutputScheme (castFX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__FX__evaluate" c_CasADi__FX__evaluate+ :: Ptr FX' -> IO ()+casADi__FX__evaluate+ :: FX -> IO ()+casADi__FX__evaluate x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__FX__evaluate x0' >>= wrapReturn++-- classy wrapper+{-|+>Evaluate.+-}+fx_evaluate :: FXClass a => a -> IO ()+fx_evaluate x = casADi__FX__evaluate (castFX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__FX__solve" c_CasADi__FX__solve+ :: Ptr FX' -> IO ()+casADi__FX__solve+ :: FX -> IO ()+casADi__FX__solve x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__FX__solve x0' >>= wrapReturn++-- classy wrapper+{-|+>the same as evaluate(0,0)+-}+fx_solve :: FXClass a => a -> IO ()+fx_solve x = casADi__FX__solve (castFX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__FX__jacobian" c_CasADi__FX__jacobian+ :: Ptr FX' -> CInt -> CInt -> Ptr CppBool' -> Ptr CppBool' -> IO (Ptr FX')+casADi__FX__jacobian+ :: FX -> Int -> Int -> Bool -> Bool -> IO FX+casADi__FX__jacobian x0 x1 x2 x3 x4 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ withMarshal x3 $ \x3' ->+ withMarshal x4 $ \x4' ->+ c_CasADi__FX__jacobian x0' x1' x2' x3' x4' >>= (newForeignPtr c_delete_CasADi__FX) >>= wrapReturn++-- classy wrapper+{-|+>Generate a Jacobian function of output oind with respect to input iind.+>+>Parameters:+>-----------+>+>iind: The index of the input+>+>oind: The index of the output+>+>The default behavior of this class is defined by the derived class. If+>compact is set to true, only the nonzeros of the input and output+>expressions are considered. If symmetric is set to true, the Jacobian being+>calculated is known to be symmetric (usually a Hessian), which can be+>exploited by the algorithm.+>+>The generated Jacobian has one more output than the calling function+>corresponding to the Jacobian and the same number of inputs.+-}+fx_jacobian :: FXClass a => a -> Int -> Int -> Bool -> Bool -> IO FX+fx_jacobian x = casADi__FX__jacobian (castFX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__FX__gradient" c_CasADi__FX__gradient+ :: Ptr FX' -> CInt -> CInt -> IO (Ptr FX')+casADi__FX__gradient+ :: FX -> Int -> Int -> IO FX+casADi__FX__gradient x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__FX__gradient x0' x1' x2' >>= (newForeignPtr c_delete_CasADi__FX) >>= wrapReturn++-- classy wrapper+{-|+>Generate a gradient function of output oind with respect to input iind.+>+>Parameters:+>-----------+>+>iind: The index of the input+>+>oind: The index of the output+>+>The default behavior of this class is defined by the derived class. Note+>that the output must be scalar. In other cases, use the Jacobian instead.+-}+fx_gradient :: FXClass a => a -> Int -> Int -> IO FX+fx_gradient x = casADi__FX__gradient (castFX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__FX__hessian" c_CasADi__FX__hessian+ :: Ptr FX' -> CInt -> CInt -> IO (Ptr FX')+casADi__FX__hessian+ :: FX -> Int -> Int -> IO FX+casADi__FX__hessian x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__FX__hessian x0' x1' x2' >>= (newForeignPtr c_delete_CasADi__FX) >>= wrapReturn++-- classy wrapper+{-|+>Generate a Hessian function of output oind with respect to input iind.+>+>Parameters:+>-----------+>+>iind: The index of the input+>+>oind: The index of the output+>+>The generated Hessian has two more outputs than the calling function+>corresponding to the Hessian and the gradients.+-}+fx_hessian :: FXClass a => a -> Int -> Int -> IO FX+fx_hessian x = casADi__FX__hessian (castFX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__FX__fullJacobian" c_CasADi__FX__fullJacobian+ :: Ptr FX' -> IO (Ptr FX')+casADi__FX__fullJacobian+ :: FX -> IO FX+casADi__FX__fullJacobian x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__FX__fullJacobian x0' >>= (newForeignPtr c_delete_CasADi__FX) >>= wrapReturn++-- classy wrapper+{-|+>Generate a Jacobian function of all the inputs nonzeros (+>getNumScalarInputs()) with respect to all the output nonzeros (+>getNumScalarOutputs()).+-}+fx_fullJacobian :: FXClass a => a -> IO FX+fx_fullJacobian x = casADi__FX__fullJacobian (castFX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__FX__call" c_CasADi__FX__call+ :: Ptr FX' -> Ptr (CppVec (Ptr MX')) -> IO (Ptr (CppVec (Ptr MX')))+casADi__FX__call+ :: FX -> Vector MX -> IO (Vector MX)+casADi__FX__call x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__FX__call x0' x1' >>= (newForeignPtr c_delete_std__vector_CasADi__MX_) >>= wrapReturn++-- classy wrapper+{-|+>> vector< MX > CasADi::FX::call(const MX &arg)+>------------------------------------------------------------------------+>+>Create a function call (single input)+>+>> std::vector<MX> CasADi::FX::call(const std::vector< MX > &arg)+>------------------------------------------------------------------------+>+>Create a function call ( MX graph)+>+>> void CasADi::FX::call(const MXVector &arg, MXVector &res, const MXVectorVector &fseed, MXVectorVector &fsens, const MXVectorVector &aseed, MXVectorVector &asens)+>------------------------------------------------------------------------+>+>Create a function call with directional derivatives Note: return by+>reference with SWIG.+>+>> std::vector<std::vector<MX> > CasADi::FX::call(const std::vector< std::vector< MX > > &arg, const Dictionary &paropt=Dictionary())+>------------------------------------------------------------------------+>+>Evaluate symbolically in parallel (matrix graph) paropt: Set of options to+>be passed to the Parallelizer.+-}+fx_call :: FXClass a => a -> Vector MX -> IO (Vector MX)+fx_call x = casADi__FX__call (castFX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__FX__call_TIC_TIC" c_CasADi__FX__call_TIC_TIC+ :: Ptr FX' -> Ptr (CppVecVec (Ptr MX')) -> IO (Ptr (CppVecVec (Ptr MX')))+casADi__FX__call''+ :: FX -> Vector (Vector MX) -> IO (Vector (Vector MX))+casADi__FX__call'' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__FX__call_TIC_TIC x0' x1' >>= (newForeignPtr c_delete_std__vector_std__vector_CasADi__MX__) >>= wrapReturn++-- classy wrapper+fx_call'' :: FXClass a => a -> Vector (Vector MX) -> IO (Vector (Vector MX))+fx_call'' x = casADi__FX__call'' (castFX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__FX__evalMX" c_CasADi__FX__evalMX+ :: Ptr FX' -> Ptr (CppVec (Ptr MX')) -> IO (Ptr (CppVec (Ptr MX')))+casADi__FX__evalMX+ :: FX -> Vector MX -> IO (Vector MX)+casADi__FX__evalMX x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__FX__evalMX x0' x1' >>= (newForeignPtr c_delete_std__vector_CasADi__MX_) >>= wrapReturn++-- classy wrapper+{-|+>> std::vector<MX> CasADi::FX::evalMX(const std::vector< MX > &arg)+>------------------------------------------------------------------------+>+>evaluate symbolically, MX type (unambiguous)+>+>> void CasADi::FX::evalMX(const MXVector &arg, MXVector &res, const MXVectorVector &fseed, MXVectorVector &fsens, const MXVectorVector &aseed, MXVectorVector &asens)+>------------------------------------------------------------------------+>+>Evaluate symbolically with with directional derivatives, MX type The first+>two arguments are the nondifferentiated inputs and results of the+>evaluation, the next two arguments are a set of forward directional seeds+>and the resulting forward directional derivatives, the length of the vector+>being the number of forward directions. The next two arguments are a set of+>adjoint directional seeds and the resulting adjoint directional derivatives,+>the length of the vector being the number of adjoint directions.+-}+fx_evalMX :: FXClass a => a -> Vector MX -> IO (Vector MX)+fx_evalMX x = casADi__FX__evalMX (castFX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__FX__evalSX" c_CasADi__FX__evalSX+ :: Ptr FX' -> Ptr (CppVec (Ptr SXMatrix')) -> IO (Ptr (CppVec (Ptr SXMatrix')))+casADi__FX__evalSX+ :: FX -> Vector SXMatrix -> IO (Vector SXMatrix)+casADi__FX__evalSX x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__FX__evalSX x0' x1' >>= (newForeignPtr c_delete_std__vector_CasADi__Matrix_CasADi__SX__) >>= wrapReturn++-- classy wrapper+{-|+>> std::vector<SXMatrix> CasADi::FX::evalSX(const std::vector< SXMatrix > &arg)+>------------------------------------------------------------------------+>+>evaluate symbolically, SX type (unambiguous)+>+>> void CasADi::FX::evalSX(const SXMatrixVector &arg, SXMatrixVector &res, const SXMatrixVectorVector &fseed, SXMatrixVectorVector &fsens, const SXMatrixVectorVector &aseed, SXMatrixVectorVector &asens)+>------------------------------------------------------------------------+>+>Evaluate symbolically with with directional derivatives, SX type The first+>two arguments are the nondifferentiated inputs and results of the+>evaluation, the next two arguments are a set of forward directional seeds+>and the resulting forward directional derivatives, the length of the vector+>being the number of forward directions. The next two arguments are a set of+>adjoint directional seeds and the resulting adjoint directional derivatives,+>the length of the vector being the number of adjoint directions.+-}+fx_evalSX :: FXClass a => a -> Vector SXMatrix -> IO (Vector SXMatrix)+fx_evalSX x = casADi__FX__evalSX (castFX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__FX__generateCode" c_CasADi__FX__generateCode+ :: Ptr FX' -> Ptr StdString' -> IO ()+casADi__FX__generateCode+ :: FX -> String -> IO ()+casADi__FX__generateCode x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__FX__generateCode x0' x1' >>= wrapReturn++-- classy wrapper+{-|+>Export / Generate C code for the function.+-}+fx_generateCode :: FXClass a => a -> String -> IO ()+fx_generateCode x = casADi__FX__generateCode (castFX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__FX__checkNode" c_CasADi__FX__checkNode+ :: Ptr FX' -> IO (Ptr CppBool')+casADi__FX__checkNode+ :: FX -> IO Bool+casADi__FX__checkNode x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__FX__checkNode x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++-- classy wrapper+{-|+>Check if the node is pointing to the right type of object.+-}+fx_checkNode :: FXClass a => a -> IO Bool+fx_checkNode x = casADi__FX__checkNode (castFX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__FX__getStat" c_CasADi__FX__getStat+ :: Ptr FX' -> Ptr StdString' -> IO (Ptr GenericType')+casADi__FX__getStat+ :: FX -> String -> IO GenericType+casADi__FX__getStat x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__FX__getStat x0' x1' >>= (newForeignPtr c_delete_CasADi__GenericType) >>= wrapReturn++-- classy wrapper+{-|+>Get a single statistic obtained at the end of the last evaluate call.+-}+fx_getStat :: FXClass a => a -> String -> IO GenericType+fx_getStat x = casADi__FX__getStat (castFX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__FX__symbolicInput" c_CasADi__FX__symbolicInput+ :: Ptr FX' -> IO (Ptr (CppVec (Ptr MX')))+casADi__FX__symbolicInput+ :: FX -> IO (Vector MX)+casADi__FX__symbolicInput x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__FX__symbolicInput x0' >>= (newForeignPtr c_delete_std__vector_CasADi__MX_) >>= wrapReturn++-- classy wrapper+{-|+>Get a vector of symbolic variables with the same dimensions as the inputs+>There is no guarantee that consecutive calls return identical objects.+-}+fx_symbolicInput :: FXClass a => a -> IO (Vector MX)+fx_symbolicInput x = casADi__FX__symbolicInput (castFX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__FX__symbolicInputSX" c_CasADi__FX__symbolicInputSX+ :: Ptr FX' -> IO (Ptr (CppVec (Ptr SXMatrix')))+casADi__FX__symbolicInputSX+ :: FX -> IO (Vector SXMatrix)+casADi__FX__symbolicInputSX x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__FX__symbolicInputSX x0' >>= (newForeignPtr c_delete_std__vector_CasADi__Matrix_CasADi__SX__) >>= wrapReturn++-- classy wrapper+{-|+>Get a vector of symbolic variables with the same dimensions as the inputs,+>SX graph There is no guarantee that consecutive calls return identical+>objects.+-}+fx_symbolicInputSX :: FXClass a => a -> IO (Vector SXMatrix)+fx_symbolicInputSX x = casADi__FX__symbolicInputSX (castFX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__FX__addMonitor" c_CasADi__FX__addMonitor+ :: Ptr FX' -> Ptr StdString' -> IO ()+casADi__FX__addMonitor+ :: FX -> String -> IO ()+casADi__FX__addMonitor x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__FX__addMonitor x0' x1' >>= wrapReturn++-- classy wrapper+{-|+>Add modules to be monitored.+-}+fx_addMonitor :: FXClass a => a -> String -> IO ()+fx_addMonitor x = casADi__FX__addMonitor (castFX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__FX__removeMonitor" c_CasADi__FX__removeMonitor+ :: Ptr FX' -> Ptr StdString' -> IO ()+casADi__FX__removeMonitor+ :: FX -> String -> IO ()+casADi__FX__removeMonitor x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__FX__removeMonitor x0' x1' >>= wrapReturn++-- classy wrapper+{-|+>Remove modules to be monitored.+-}+fx_removeMonitor :: FXClass a => a -> String -> IO ()+fx_removeMonitor x = casADi__FX__removeMonitor (castFX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__FX__checkInputs" c_CasADi__FX__checkInputs+ :: Ptr FX' -> IO ()+casADi__FX__checkInputs+ :: FX -> IO ()+casADi__FX__checkInputs x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__FX__checkInputs x0' >>= wrapReturn++-- classy wrapper+{-|+>Check if the numerical values of the supplied bounds make sense.+-}+fx_checkInputs :: FXClass a => a -> IO ()+fx_checkInputs x = casADi__FX__checkInputs (castFX x)+
+ Casadi/Wrappers/Classes/Functor.hs view
@@ -0,0 +1,34 @@+{-# OPTIONS_GHC -Wall #-}+{-# OPTIONS_GHC -fno-warn-unused-imports #-}+{-# OPTIONS_GHC -fno-warn-orphans #-}+{-# Language ForeignFunctionInterface #-}+{-# Language FlexibleInstances #-}+{-# Language MultiParamTypeClasses #-}++module Casadi.Wrappers.Classes.Functor+ (+ Functor,+ FunctorClass(..),+ ) where+++import Prelude hiding ( Functor )++import Data.Vector ( Vector )+import Foreign.C.Types+import Foreign.Ptr ( Ptr )+import Foreign.ForeignPtr ( newForeignPtr )+import System.IO.Unsafe ( unsafePerformIO ) -- for show instances++import Casadi.Wrappers.Classes.PrintableObject+import Casadi.Wrappers.ForeignToolsInstances ( )+import Casadi.Wrappers.Deleters+import Casadi.Wrappers.Data+import Casadi.Wrappers.Enums+import Casadi.MarshalTypes ( CppVec, CppVecVec, CppVecVecVec,+ StdString', CppBool' ) -- StdOstream'+import Casadi.Marshal ( CornerCase(..), Marshal(..) )+import Casadi.WrapReturn ( WrapReturn(..) )++instance Show Functor where+ show = unsafePerformIO . printableObject_getDescription
+ Casadi/Wrappers/Classes/GenericType.hs view
@@ -0,0 +1,576 @@+{-# OPTIONS_GHC -Wall #-}+{-# OPTIONS_GHC -fno-warn-unused-imports #-}+{-# OPTIONS_GHC -fno-warn-orphans #-}+{-# Language ForeignFunctionInterface #-}+{-# Language FlexibleInstances #-}+{-# Language MultiParamTypeClasses #-}++module Casadi.Wrappers.Classes.GenericType+ (+ GenericType,+ GenericTypeClass(..),+ genericType,+ genericTypeBool,+ genericTypeBoolVec,+ genericTypeCallback,+ genericTypeDouble,+ genericTypeDoubleVec,+ genericTypeFX,+ genericTypeInt,+ genericTypeIntVec,+ genericTypeString,+ genericTypeStringVec,+ genericType_can_cast_to,+ genericType_can_cast_to',+ genericType_from_type,+ genericType_getType,+ genericType_get_description,+ genericType_get_type_description,+ genericType_isBool,+ genericType_isDictionary,+ genericType_isDouble,+ genericType_isDoubleVector,+ genericType_isEmptyVector,+ genericType_isFX,+ genericType_isInt,+ genericType_isIntVector,+ genericType_isSharedObject,+ genericType_isString,+ genericType_isStringVector,+ genericType_operator_equals,+ genericType_operator_nequals,+ genericType_toBool,+ genericType_toDouble,+ genericType_toInt,+ ) where+++import Prelude hiding ( Functor )++import Data.Vector ( Vector )+import Foreign.C.Types+import Foreign.Ptr ( Ptr )+import Foreign.ForeignPtr ( newForeignPtr )+import System.IO.Unsafe ( unsafePerformIO ) -- for show instances++import Casadi.Wrappers.Classes.PrintableObject+import Casadi.Wrappers.ForeignToolsInstances ( )+import Casadi.Wrappers.Deleters+import Casadi.Wrappers.Data+import Casadi.Wrappers.Enums+import Casadi.MarshalTypes ( CppVec, CppVecVec, CppVecVecVec,+ StdString', CppBool' ) -- StdOstream'+import Casadi.Marshal ( CornerCase(..), Marshal(..) )+import Casadi.WrapReturn ( WrapReturn(..) )++instance Show GenericType where+ show = unsafePerformIO . printableObject_getDescription+-- direct wrapper+foreign import ccall unsafe "CasADi__GenericType__get_type_description" c_CasADi__GenericType__get_type_description+ :: CInt -> IO (Ptr StdString')+casADi__GenericType__get_type_description+ :: Opt_type -> IO String+casADi__GenericType__get_type_description x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__GenericType__get_type_description x0' >>= (newForeignPtr c_delete_std__string) >>= wrapReturn++-- classy wrapper+genericType_get_type_description :: Opt_type -> IO String+genericType_get_type_description = casADi__GenericType__get_type_description+++-- direct wrapper+foreign import ccall unsafe "CasADi__GenericType__get_description" c_CasADi__GenericType__get_description+ :: Ptr GenericType' -> IO (Ptr StdString')+casADi__GenericType__get_description+ :: GenericType -> IO String+casADi__GenericType__get_description x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__GenericType__get_description x0' >>= (newForeignPtr c_delete_std__string) >>= wrapReturn++-- classy wrapper+{-|+>Get a description of the object's type.+-}+genericType_get_description :: GenericTypeClass a => a -> IO String+genericType_get_description x = casADi__GenericType__get_description (castGenericType x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__GenericType__from_type" c_CasADi__GenericType__from_type+ :: CInt -> IO (Ptr GenericType')+casADi__GenericType__from_type+ :: Opt_type -> IO GenericType+casADi__GenericType__from_type x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__GenericType__from_type x0' >>= (newForeignPtr c_delete_CasADi__GenericType) >>= wrapReturn++-- classy wrapper+genericType_from_type :: Opt_type -> IO GenericType+genericType_from_type = casADi__GenericType__from_type+++-- direct wrapper+foreign import ccall unsafe "CasADi__GenericType__getType" c_CasADi__GenericType__getType+ :: Ptr GenericType' -> IO CInt+casADi__GenericType__getType+ :: GenericType -> IO Opt_type+casADi__GenericType__getType x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__GenericType__getType x0' >>= wrapReturn++-- classy wrapper+genericType_getType :: GenericTypeClass a => a -> IO Opt_type+genericType_getType x = casADi__GenericType__getType (castGenericType x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__GenericType__can_cast_to" c_CasADi__GenericType__can_cast_to+ :: Ptr GenericType' -> CInt -> IO (Ptr CppBool')+casADi__GenericType__can_cast_to+ :: GenericType -> Opt_type -> IO Bool+casADi__GenericType__can_cast_to x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__GenericType__can_cast_to x0' x1' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++-- classy wrapper+genericType_can_cast_to :: GenericTypeClass a => a -> Opt_type -> IO Bool+genericType_can_cast_to x = casADi__GenericType__can_cast_to (castGenericType x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__GenericType__can_cast_to_TIC" c_CasADi__GenericType__can_cast_to_TIC+ :: Ptr GenericType' -> Ptr GenericType' -> IO (Ptr CppBool')+casADi__GenericType__can_cast_to'+ :: GenericType -> GenericType -> IO Bool+casADi__GenericType__can_cast_to' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__GenericType__can_cast_to_TIC x0' x1' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++-- classy wrapper+genericType_can_cast_to' :: GenericTypeClass a => a -> GenericType -> IO Bool+genericType_can_cast_to' x = casADi__GenericType__can_cast_to' (castGenericType x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__GenericType__isBool" c_CasADi__GenericType__isBool+ :: Ptr GenericType' -> IO (Ptr CppBool')+casADi__GenericType__isBool+ :: GenericType -> IO Bool+casADi__GenericType__isBool x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__GenericType__isBool x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++-- classy wrapper+{-|+>Is boolean?+-}+genericType_isBool :: GenericTypeClass a => a -> IO Bool+genericType_isBool x = casADi__GenericType__isBool (castGenericType x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__GenericType__isInt" c_CasADi__GenericType__isInt+ :: Ptr GenericType' -> IO (Ptr CppBool')+casADi__GenericType__isInt+ :: GenericType -> IO Bool+casADi__GenericType__isInt x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__GenericType__isInt x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++-- classy wrapper+{-|+>Is an integer?+-}+genericType_isInt :: GenericTypeClass a => a -> IO Bool+genericType_isInt x = casADi__GenericType__isInt (castGenericType x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__GenericType__isDouble" c_CasADi__GenericType__isDouble+ :: Ptr GenericType' -> IO (Ptr CppBool')+casADi__GenericType__isDouble+ :: GenericType -> IO Bool+casADi__GenericType__isDouble x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__GenericType__isDouble x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++-- classy wrapper+{-|+>Is a double?+-}+genericType_isDouble :: GenericTypeClass a => a -> IO Bool+genericType_isDouble x = casADi__GenericType__isDouble (castGenericType x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__GenericType__isString" c_CasADi__GenericType__isString+ :: Ptr GenericType' -> IO (Ptr CppBool')+casADi__GenericType__isString+ :: GenericType -> IO Bool+casADi__GenericType__isString x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__GenericType__isString x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++-- classy wrapper+{-|+>Is a string?+-}+genericType_isString :: GenericTypeClass a => a -> IO Bool+genericType_isString x = casADi__GenericType__isString (castGenericType x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__GenericType__isEmptyVector" c_CasADi__GenericType__isEmptyVector+ :: Ptr GenericType' -> IO (Ptr CppBool')+casADi__GenericType__isEmptyVector+ :: GenericType -> IO Bool+casADi__GenericType__isEmptyVector x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__GenericType__isEmptyVector x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++-- classy wrapper+{-|+>Is an empty vector?+-}+genericType_isEmptyVector :: GenericTypeClass a => a -> IO Bool+genericType_isEmptyVector x = casADi__GenericType__isEmptyVector (castGenericType x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__GenericType__isIntVector" c_CasADi__GenericType__isIntVector+ :: Ptr GenericType' -> IO (Ptr CppBool')+casADi__GenericType__isIntVector+ :: GenericType -> IO Bool+casADi__GenericType__isIntVector x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__GenericType__isIntVector x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++-- classy wrapper+{-|+>Is a vector of ints?+-}+genericType_isIntVector :: GenericTypeClass a => a -> IO Bool+genericType_isIntVector x = casADi__GenericType__isIntVector (castGenericType x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__GenericType__isDoubleVector" c_CasADi__GenericType__isDoubleVector+ :: Ptr GenericType' -> IO (Ptr CppBool')+casADi__GenericType__isDoubleVector+ :: GenericType -> IO Bool+casADi__GenericType__isDoubleVector x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__GenericType__isDoubleVector x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++-- classy wrapper+{-|+>Is a vector of doubles?+-}+genericType_isDoubleVector :: GenericTypeClass a => a -> IO Bool+genericType_isDoubleVector x = casADi__GenericType__isDoubleVector (castGenericType x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__GenericType__isStringVector" c_CasADi__GenericType__isStringVector+ :: Ptr GenericType' -> IO (Ptr CppBool')+casADi__GenericType__isStringVector+ :: GenericType -> IO Bool+casADi__GenericType__isStringVector x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__GenericType__isStringVector x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++-- classy wrapper+{-|+>Is a vector of strings.+-}+genericType_isStringVector :: GenericTypeClass a => a -> IO Bool+genericType_isStringVector x = casADi__GenericType__isStringVector (castGenericType x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__GenericType__isSharedObject" c_CasADi__GenericType__isSharedObject+ :: Ptr GenericType' -> IO (Ptr CppBool')+casADi__GenericType__isSharedObject+ :: GenericType -> IO Bool+casADi__GenericType__isSharedObject x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__GenericType__isSharedObject x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++-- classy wrapper+{-|+>Is a shared object?+-}+genericType_isSharedObject :: GenericTypeClass a => a -> IO Bool+genericType_isSharedObject x = casADi__GenericType__isSharedObject (castGenericType x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__GenericType__isDictionary" c_CasADi__GenericType__isDictionary+ :: Ptr GenericType' -> IO (Ptr CppBool')+casADi__GenericType__isDictionary+ :: GenericType -> IO Bool+casADi__GenericType__isDictionary x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__GenericType__isDictionary x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++-- classy wrapper+{-|+>Is a shared object?+-}+genericType_isDictionary :: GenericTypeClass a => a -> IO Bool+genericType_isDictionary x = casADi__GenericType__isDictionary (castGenericType x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__GenericType__isFX" c_CasADi__GenericType__isFX+ :: Ptr GenericType' -> IO (Ptr CppBool')+casADi__GenericType__isFX+ :: GenericType -> IO Bool+casADi__GenericType__isFX x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__GenericType__isFX x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++-- classy wrapper+{-|+>Is a shared object?+-}+genericType_isFX :: GenericTypeClass a => a -> IO Bool+genericType_isFX x = casADi__GenericType__isFX (castGenericType x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__GenericType__toBool" c_CasADi__GenericType__toBool+ :: Ptr GenericType' -> IO (Ptr CppBool')+casADi__GenericType__toBool+ :: GenericType -> IO Bool+casADi__GenericType__toBool x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__GenericType__toBool x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++-- classy wrapper+{-|+>Convert to boolean.+-}+genericType_toBool :: GenericTypeClass a => a -> IO Bool+genericType_toBool x = casADi__GenericType__toBool (castGenericType x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__GenericType__toInt" c_CasADi__GenericType__toInt+ :: Ptr GenericType' -> IO CInt+casADi__GenericType__toInt+ :: GenericType -> IO Int+casADi__GenericType__toInt x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__GenericType__toInt x0' >>= wrapReturn++-- classy wrapper+{-|+>Convert to int.+-}+genericType_toInt :: GenericTypeClass a => a -> IO Int+genericType_toInt x = casADi__GenericType__toInt (castGenericType x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__GenericType__toDouble" c_CasADi__GenericType__toDouble+ :: Ptr GenericType' -> IO CDouble+casADi__GenericType__toDouble+ :: GenericType -> IO Double+casADi__GenericType__toDouble x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__GenericType__toDouble x0' >>= wrapReturn++-- classy wrapper+{-|+>Convert to double.+-}+genericType_toDouble :: GenericTypeClass a => a -> IO Double+genericType_toDouble x = casADi__GenericType__toDouble (castGenericType x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__GenericType__operator_equals" c_CasADi__GenericType__operator_equals+ :: Ptr GenericType' -> Ptr GenericType' -> IO (Ptr CppBool')+casADi__GenericType__operator_equals+ :: GenericType -> GenericType -> IO Bool+casADi__GenericType__operator_equals x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__GenericType__operator_equals x0' x1' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++-- classy wrapper+genericType_operator_equals :: GenericTypeClass a => a -> GenericType -> IO Bool+genericType_operator_equals x = casADi__GenericType__operator_equals (castGenericType x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__GenericType__operator_nequals" c_CasADi__GenericType__operator_nequals+ :: Ptr GenericType' -> Ptr GenericType' -> IO (Ptr CppBool')+casADi__GenericType__operator_nequals+ :: GenericType -> GenericType -> IO Bool+casADi__GenericType__operator_nequals x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__GenericType__operator_nequals x0' x1' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++-- classy wrapper+genericType_operator_nequals :: GenericTypeClass a => a -> GenericType -> IO Bool+genericType_operator_nequals x = casADi__GenericType__operator_nequals (castGenericType x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__GenericType__GenericTypeBool" c_CasADi__GenericType__GenericTypeBool+ :: Ptr CppBool' -> IO (Ptr GenericType')+casADi__GenericType__GenericTypeBool+ :: Bool -> IO GenericType+casADi__GenericType__GenericTypeBool x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__GenericType__GenericTypeBool x0' >>= (newForeignPtr c_delete_CasADi__GenericType) >>= wrapReturn++-- classy wrapper+genericTypeBool :: Bool -> IO GenericType+genericTypeBool = casADi__GenericType__GenericTypeBool+++-- direct wrapper+foreign import ccall unsafe "CasADi__GenericType__GenericTypeInt" c_CasADi__GenericType__GenericTypeInt+ :: CInt -> IO (Ptr GenericType')+casADi__GenericType__GenericTypeInt+ :: Int -> IO GenericType+casADi__GenericType__GenericTypeInt x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__GenericType__GenericTypeInt x0' >>= (newForeignPtr c_delete_CasADi__GenericType) >>= wrapReturn++-- classy wrapper+genericTypeInt :: Int -> IO GenericType+genericTypeInt = casADi__GenericType__GenericTypeInt+++-- direct wrapper+foreign import ccall unsafe "CasADi__GenericType__GenericTypeDouble" c_CasADi__GenericType__GenericTypeDouble+ :: CDouble -> IO (Ptr GenericType')+casADi__GenericType__GenericTypeDouble+ :: Double -> IO GenericType+casADi__GenericType__GenericTypeDouble x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__GenericType__GenericTypeDouble x0' >>= (newForeignPtr c_delete_CasADi__GenericType) >>= wrapReturn++-- classy wrapper+genericTypeDouble :: Double -> IO GenericType+genericTypeDouble = casADi__GenericType__GenericTypeDouble+++-- direct wrapper+foreign import ccall unsafe "CasADi__GenericType__GenericTypeString" c_CasADi__GenericType__GenericTypeString+ :: Ptr StdString' -> IO (Ptr GenericType')+casADi__GenericType__GenericTypeString+ :: String -> IO GenericType+casADi__GenericType__GenericTypeString x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__GenericType__GenericTypeString x0' >>= (newForeignPtr c_delete_CasADi__GenericType) >>= wrapReturn++-- classy wrapper+genericTypeString :: String -> IO GenericType+genericTypeString = casADi__GenericType__GenericTypeString+++-- direct wrapper+foreign import ccall unsafe "CasADi__GenericType__GenericTypeBoolVec" c_CasADi__GenericType__GenericTypeBoolVec+ :: Ptr (CppVec (Ptr CppBool')) -> IO (Ptr GenericType')+casADi__GenericType__GenericTypeBoolVec+ :: Vector Bool -> IO GenericType+casADi__GenericType__GenericTypeBoolVec x0 =+ withMarshal (CornerCase x0) $ \x0' ->+ c_CasADi__GenericType__GenericTypeBoolVec x0' >>= (newForeignPtr c_delete_CasADi__GenericType) >>= wrapReturn++-- classy wrapper+genericTypeBoolVec :: Vector Bool -> IO GenericType+genericTypeBoolVec = casADi__GenericType__GenericTypeBoolVec+++-- direct wrapper+foreign import ccall unsafe "CasADi__GenericType__GenericTypeIntVec" c_CasADi__GenericType__GenericTypeIntVec+ :: Ptr (CppVec CInt) -> IO (Ptr GenericType')+casADi__GenericType__GenericTypeIntVec+ :: Vector Int -> IO GenericType+casADi__GenericType__GenericTypeIntVec x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__GenericType__GenericTypeIntVec x0' >>= (newForeignPtr c_delete_CasADi__GenericType) >>= wrapReturn++-- classy wrapper+genericTypeIntVec :: Vector Int -> IO GenericType+genericTypeIntVec = casADi__GenericType__GenericTypeIntVec+++-- direct wrapper+foreign import ccall unsafe "CasADi__GenericType__GenericTypeDoubleVec" c_CasADi__GenericType__GenericTypeDoubleVec+ :: Ptr (CppVec CDouble) -> IO (Ptr GenericType')+casADi__GenericType__GenericTypeDoubleVec+ :: Vector Double -> IO GenericType+casADi__GenericType__GenericTypeDoubleVec x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__GenericType__GenericTypeDoubleVec x0' >>= (newForeignPtr c_delete_CasADi__GenericType) >>= wrapReturn++-- classy wrapper+genericTypeDoubleVec :: Vector Double -> IO GenericType+genericTypeDoubleVec = casADi__GenericType__GenericTypeDoubleVec+++-- direct wrapper+foreign import ccall unsafe "CasADi__GenericType__GenericTypeStringVec" c_CasADi__GenericType__GenericTypeStringVec+ :: Ptr (CppVec (Ptr StdString')) -> IO (Ptr GenericType')+casADi__GenericType__GenericTypeStringVec+ :: Vector String -> IO GenericType+casADi__GenericType__GenericTypeStringVec x0 =+ withMarshal (CornerCase x0) $ \x0' ->+ c_CasADi__GenericType__GenericTypeStringVec x0' >>= (newForeignPtr c_delete_CasADi__GenericType) >>= wrapReturn++-- classy wrapper+genericTypeStringVec :: Vector String -> IO GenericType+genericTypeStringVec = casADi__GenericType__GenericTypeStringVec+++-- direct wrapper+foreign import ccall unsafe "CasADi__GenericType__GenericTypeFX" c_CasADi__GenericType__GenericTypeFX+ :: Ptr FX' -> IO (Ptr GenericType')+casADi__GenericType__GenericTypeFX+ :: FX -> IO GenericType+casADi__GenericType__GenericTypeFX x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__GenericType__GenericTypeFX x0' >>= (newForeignPtr c_delete_CasADi__GenericType) >>= wrapReturn++-- classy wrapper+genericTypeFX :: FX -> IO GenericType+genericTypeFX = casADi__GenericType__GenericTypeFX+++-- direct wrapper+foreign import ccall unsafe "CasADi__GenericType__GenericTypeCallback" c_CasADi__GenericType__GenericTypeCallback+ :: Ptr Callback' -> IO (Ptr GenericType')+casADi__GenericType__GenericTypeCallback+ :: Callback -> IO GenericType+casADi__GenericType__GenericTypeCallback x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__GenericType__GenericTypeCallback x0' >>= (newForeignPtr c_delete_CasADi__GenericType) >>= wrapReturn++-- classy wrapper+genericTypeCallback :: Callback -> IO GenericType+genericTypeCallback = casADi__GenericType__GenericTypeCallback+++-- direct wrapper+foreign import ccall unsafe "CasADi__GenericType__GenericType" c_CasADi__GenericType__GenericType+ :: IO (Ptr GenericType')+casADi__GenericType__GenericType+ :: IO GenericType+casADi__GenericType__GenericType =+ c_CasADi__GenericType__GenericType >>= (newForeignPtr c_delete_CasADi__GenericType) >>= wrapReturn++-- classy wrapper+genericType :: IO GenericType+genericType = casADi__GenericType__GenericType+
+ Casadi/Wrappers/Classes/IOInterfaceFX.hs view
@@ -0,0 +1,558 @@+{-# OPTIONS_GHC -Wall #-}+{-# OPTIONS_GHC -fno-warn-unused-imports #-}+{-# OPTIONS_GHC -fno-warn-orphans #-}+{-# Language ForeignFunctionInterface #-}+{-# Language FlexibleInstances #-}+{-# Language MultiParamTypeClasses #-}++module Casadi.Wrappers.Classes.IOInterfaceFX+ (+ IOInterfaceFX,+ IOInterfaceFXClass(..),+ ioInterfaceFX_getInputScheme,+ ioInterfaceFX_getNumInputs,+ ioInterfaceFX_getNumOutputs,+ ioInterfaceFX_getOutputScheme,+ ioInterfaceFX_input,+ ioInterfaceFX_input',+ ioInterfaceFX_input'',+ ioInterfaceFX_inputSchemeEntry,+ ioInterfaceFX_output,+ ioInterfaceFX_output',+ ioInterfaceFX_output'',+ ioInterfaceFX_outputSchemeEntry,+ ioInterfaceFX_schemeEntry,+ ioInterfaceFX_setInput,+ ioInterfaceFX_setInput',+ ioInterfaceFX_setInput''',+ ioInterfaceFX_setInput'''',+ ioInterfaceFX_setInput''''',+ ioInterfaceFX_setInput'''''',+ ioInterfaceFX_setInput''''''',+ ioInterfaceFX_setInput'''''''',+ ioInterfaceFX_setOutput,+ ioInterfaceFX_setOutput',+ ioInterfaceFX_setOutput'',+ ioInterfaceFX_setOutput''',+ ioInterfaceFX_setOutput'''',+ ioInterfaceFX_setOutput''''',+ ioInterfaceFX_setOutput'''''',+ ioInterfaceFX_setOutput''''''',+ ioInterfaceFX_setOutput'''''''',+ ) 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.ForeignToolsInstances ( )+import Casadi.Wrappers.Deleters+import Casadi.Wrappers.Data+import Casadi.Wrappers.Enums+import Casadi.MarshalTypes ( CppVec, CppVecVec, CppVecVecVec,+ StdString', CppBool' ) -- StdOstream'+import Casadi.Marshal ( CornerCase(..), Marshal(..) )+import Casadi.WrapReturn ( WrapReturn(..) )++-- direct wrapper+foreign import ccall unsafe "CasADi__IOInterface_CasADi__FX___input" c_CasADi__IOInterface_CasADi__FX___input+ :: Ptr IOInterfaceFX' -> CInt -> IO (Ptr DMatrix')+casADi__IOInterface_CasADi__FX___input+ :: IOInterfaceFX -> Int -> IO DMatrix+casADi__IOInterface_CasADi__FX___input x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__IOInterface_CasADi__FX___input x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++-- classy wrapper+{-|+>Access input argument.+-}+ioInterfaceFX_input :: IOInterfaceFXClass a => a -> Int -> IO DMatrix+ioInterfaceFX_input x = casADi__IOInterface_CasADi__FX___input (castIOInterfaceFX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__IOInterface_CasADi__FX___input_TIC" c_CasADi__IOInterface_CasADi__FX___input_TIC+ :: Ptr IOInterfaceFX' -> IO (Ptr DMatrix')+casADi__IOInterface_CasADi__FX___input'+ :: IOInterfaceFX -> IO DMatrix+casADi__IOInterface_CasADi__FX___input' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__IOInterface_CasADi__FX___input_TIC x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++-- classy wrapper+ioInterfaceFX_input' :: IOInterfaceFXClass a => a -> IO DMatrix+ioInterfaceFX_input' x = casADi__IOInterface_CasADi__FX___input' (castIOInterfaceFX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__IOInterface_CasADi__FX___input_TIC_TIC" c_CasADi__IOInterface_CasADi__FX___input_TIC_TIC+ :: Ptr IOInterfaceFX' -> Ptr StdString' -> IO (Ptr DMatrix')+casADi__IOInterface_CasADi__FX___input''+ :: IOInterfaceFX -> String -> IO DMatrix+casADi__IOInterface_CasADi__FX___input'' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__IOInterface_CasADi__FX___input_TIC_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++-- classy wrapper+ioInterfaceFX_input'' :: IOInterfaceFXClass a => a -> String -> IO DMatrix+ioInterfaceFX_input'' x = casADi__IOInterface_CasADi__FX___input'' (castIOInterfaceFX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__IOInterface_CasADi__FX___output" c_CasADi__IOInterface_CasADi__FX___output+ :: Ptr IOInterfaceFX' -> CInt -> IO (Ptr DMatrix')+casADi__IOInterface_CasADi__FX___output+ :: IOInterfaceFX -> Int -> IO DMatrix+casADi__IOInterface_CasADi__FX___output x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__IOInterface_CasADi__FX___output x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++-- classy wrapper+{-|+>Access output argument.+-}+ioInterfaceFX_output :: IOInterfaceFXClass a => a -> Int -> IO DMatrix+ioInterfaceFX_output x = casADi__IOInterface_CasADi__FX___output (castIOInterfaceFX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__IOInterface_CasADi__FX___output_TIC" c_CasADi__IOInterface_CasADi__FX___output_TIC+ :: Ptr IOInterfaceFX' -> IO (Ptr DMatrix')+casADi__IOInterface_CasADi__FX___output'+ :: IOInterfaceFX -> IO DMatrix+casADi__IOInterface_CasADi__FX___output' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__IOInterface_CasADi__FX___output_TIC x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++-- classy wrapper+ioInterfaceFX_output' :: IOInterfaceFXClass a => a -> IO DMatrix+ioInterfaceFX_output' x = casADi__IOInterface_CasADi__FX___output' (castIOInterfaceFX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__IOInterface_CasADi__FX___output_TIC_TIC" c_CasADi__IOInterface_CasADi__FX___output_TIC_TIC+ :: Ptr IOInterfaceFX' -> Ptr StdString' -> IO (Ptr DMatrix')+casADi__IOInterface_CasADi__FX___output''+ :: IOInterfaceFX -> String -> IO DMatrix+casADi__IOInterface_CasADi__FX___output'' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__IOInterface_CasADi__FX___output_TIC_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++-- classy wrapper+ioInterfaceFX_output'' :: IOInterfaceFXClass a => a -> String -> IO DMatrix+ioInterfaceFX_output'' x = casADi__IOInterface_CasADi__FX___output'' (castIOInterfaceFX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__IOInterface_CasADi__FX___getNumInputs" c_CasADi__IOInterface_CasADi__FX___getNumInputs+ :: Ptr IOInterfaceFX' -> IO CInt+casADi__IOInterface_CasADi__FX___getNumInputs+ :: IOInterfaceFX -> IO Int+casADi__IOInterface_CasADi__FX___getNumInputs x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__IOInterface_CasADi__FX___getNumInputs x0' >>= wrapReturn++-- classy wrapper+{-|+>Get the number of function inputs.+-}+ioInterfaceFX_getNumInputs :: IOInterfaceFXClass a => a -> IO Int+ioInterfaceFX_getNumInputs x = casADi__IOInterface_CasADi__FX___getNumInputs (castIOInterfaceFX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__IOInterface_CasADi__FX___getNumOutputs" c_CasADi__IOInterface_CasADi__FX___getNumOutputs+ :: Ptr IOInterfaceFX' -> IO CInt+casADi__IOInterface_CasADi__FX___getNumOutputs+ :: IOInterfaceFX -> IO Int+casADi__IOInterface_CasADi__FX___getNumOutputs x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__IOInterface_CasADi__FX___getNumOutputs x0' >>= wrapReturn++-- classy wrapper+{-|+>Get the number of function outputs.+-}+ioInterfaceFX_getNumOutputs :: IOInterfaceFXClass a => a -> IO Int+ioInterfaceFX_getNumOutputs x = casADi__IOInterface_CasADi__FX___getNumOutputs (castIOInterfaceFX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__IOInterface_CasADi__FX___getInputScheme" c_CasADi__IOInterface_CasADi__FX___getInputScheme+ :: Ptr IOInterfaceFX' -> IO (Ptr IOScheme')+casADi__IOInterface_CasADi__FX___getInputScheme+ :: IOInterfaceFX -> IO IOScheme+casADi__IOInterface_CasADi__FX___getInputScheme x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__IOInterface_CasADi__FX___getInputScheme x0' >>= (newForeignPtr c_delete_CasADi__IOScheme) >>= wrapReturn++-- classy wrapper+{-|+>Get input scheme.+-}+ioInterfaceFX_getInputScheme :: IOInterfaceFXClass a => a -> IO IOScheme+ioInterfaceFX_getInputScheme x = casADi__IOInterface_CasADi__FX___getInputScheme (castIOInterfaceFX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__IOInterface_CasADi__FX___getOutputScheme" c_CasADi__IOInterface_CasADi__FX___getOutputScheme+ :: Ptr IOInterfaceFX' -> IO (Ptr IOScheme')+casADi__IOInterface_CasADi__FX___getOutputScheme+ :: IOInterfaceFX -> IO IOScheme+casADi__IOInterface_CasADi__FX___getOutputScheme x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__IOInterface_CasADi__FX___getOutputScheme x0' >>= (newForeignPtr c_delete_CasADi__IOScheme) >>= wrapReturn++-- classy wrapper+{-|+>Get output scheme.+-}+ioInterfaceFX_getOutputScheme :: IOInterfaceFXClass a => a -> IO IOScheme+ioInterfaceFX_getOutputScheme x = casADi__IOInterface_CasADi__FX___getOutputScheme (castIOInterfaceFX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__IOInterface_CasADi__FX___inputSchemeEntry" c_CasADi__IOInterface_CasADi__FX___inputSchemeEntry+ :: Ptr IOInterfaceFX' -> Ptr StdString' -> IO CInt+casADi__IOInterface_CasADi__FX___inputSchemeEntry+ :: IOInterfaceFX -> String -> IO Int+casADi__IOInterface_CasADi__FX___inputSchemeEntry x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__IOInterface_CasADi__FX___inputSchemeEntry x0' x1' >>= wrapReturn++-- classy wrapper+{-|+>Find the index for a string describing a particular entry of an input scheme+>example: schemeEntry("x_opt") -> returns NLP_SOLVER_X if FXInternal+>adheres to SCHEME_NLPINput.+-}+ioInterfaceFX_inputSchemeEntry :: IOInterfaceFXClass a => a -> String -> IO Int+ioInterfaceFX_inputSchemeEntry x = casADi__IOInterface_CasADi__FX___inputSchemeEntry (castIOInterfaceFX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__IOInterface_CasADi__FX___outputSchemeEntry" c_CasADi__IOInterface_CasADi__FX___outputSchemeEntry+ :: Ptr IOInterfaceFX' -> Ptr StdString' -> IO CInt+casADi__IOInterface_CasADi__FX___outputSchemeEntry+ :: IOInterfaceFX -> String -> IO Int+casADi__IOInterface_CasADi__FX___outputSchemeEntry x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__IOInterface_CasADi__FX___outputSchemeEntry x0' x1' >>= wrapReturn++-- classy wrapper+{-|+>Find the index for a string describing a particular entry of an output+>scheme example: schemeEntry("x_opt") -> returns NLP_SOLVER_X if FXInternal+>adheres to SCHEME_NLPINput.+-}+ioInterfaceFX_outputSchemeEntry :: IOInterfaceFXClass a => a -> String -> IO Int+ioInterfaceFX_outputSchemeEntry x = casADi__IOInterface_CasADi__FX___outputSchemeEntry (castIOInterfaceFX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__IOInterface_CasADi__FX___schemeEntry" c_CasADi__IOInterface_CasADi__FX___schemeEntry+ :: Ptr IOInterfaceFX' -> Ptr IOScheme' -> Ptr StdString' -> Ptr CppBool' -> IO CInt+casADi__IOInterface_CasADi__FX___schemeEntry+ :: IOInterfaceFX -> IOScheme -> String -> Bool -> IO Int+casADi__IOInterface_CasADi__FX___schemeEntry x0 x1 x2 x3 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ withMarshal x3 $ \x3' ->+ c_CasADi__IOInterface_CasADi__FX___schemeEntry x0' x1' x2' x3' >>= wrapReturn++-- classy wrapper+{-|+>Find the index for a string describing a particular entry of a scheme+>example: schemeEntry("x_opt") -> returns NLP_SOLVER_X if FXInternal+>adheres to SCHEME_NLPINput.+-}+ioInterfaceFX_schemeEntry :: IOInterfaceFXClass a => a -> IOScheme -> String -> Bool -> IO Int+ioInterfaceFX_schemeEntry x = casADi__IOInterface_CasADi__FX___schemeEntry (castIOInterfaceFX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__IOInterface_CasADi__FX___setInput" c_CasADi__IOInterface_CasADi__FX___setInput+ :: Ptr IOInterfaceFX' -> CDouble -> CInt -> IO ()+casADi__IOInterface_CasADi__FX___setInput+ :: IOInterfaceFX -> Double -> Int -> IO ()+casADi__IOInterface_CasADi__FX___setInput x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__IOInterface_CasADi__FX___setInput x0' x1' x2' >>= wrapReturn++-- classy wrapper+{-|+>Reads in the input argument from val. T can be double&, double*,+>std::vector<double>&, Matrix<double> & Assumes a properly allocated val. .+-}+ioInterfaceFX_setInput :: IOInterfaceFXClass a => a -> Double -> Int -> IO ()+ioInterfaceFX_setInput x = casADi__IOInterface_CasADi__FX___setInput (castIOInterfaceFX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__IOInterface_CasADi__FX___setInput_TIC" c_CasADi__IOInterface_CasADi__FX___setInput_TIC+ :: Ptr IOInterfaceFX' -> CDouble -> IO ()+casADi__IOInterface_CasADi__FX___setInput'+ :: IOInterfaceFX -> Double -> IO ()+casADi__IOInterface_CasADi__FX___setInput' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__IOInterface_CasADi__FX___setInput_TIC x0' x1' >>= wrapReturn++-- classy wrapper+ioInterfaceFX_setInput' :: IOInterfaceFXClass a => a -> Double -> IO ()+ioInterfaceFX_setInput' x = casADi__IOInterface_CasADi__FX___setInput' (castIOInterfaceFX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__IOInterface_CasADi__FX___setOutput" c_CasADi__IOInterface_CasADi__FX___setOutput+ :: Ptr IOInterfaceFX' -> CDouble -> CInt -> IO ()+casADi__IOInterface_CasADi__FX___setOutput+ :: IOInterfaceFX -> Double -> Int -> IO ()+casADi__IOInterface_CasADi__FX___setOutput x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__IOInterface_CasADi__FX___setOutput x0' x1' x2' >>= wrapReturn++-- classy wrapper+{-|+>Reads in the output argument from val. T can be double&, double*,+>std::vector<double>&, Matrix<double> & Assumes a properly allocated val. .+-}+ioInterfaceFX_setOutput :: IOInterfaceFXClass a => a -> Double -> Int -> IO ()+ioInterfaceFX_setOutput x = casADi__IOInterface_CasADi__FX___setOutput (castIOInterfaceFX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__IOInterface_CasADi__FX___setOutput_TIC" c_CasADi__IOInterface_CasADi__FX___setOutput_TIC+ :: Ptr IOInterfaceFX' -> CDouble -> IO ()+casADi__IOInterface_CasADi__FX___setOutput'+ :: IOInterfaceFX -> Double -> IO ()+casADi__IOInterface_CasADi__FX___setOutput' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__IOInterface_CasADi__FX___setOutput_TIC x0' x1' >>= wrapReturn++-- classy wrapper+ioInterfaceFX_setOutput' :: IOInterfaceFXClass a => a -> Double -> IO ()+ioInterfaceFX_setOutput' x = casADi__IOInterface_CasADi__FX___setOutput' (castIOInterfaceFX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__IOInterface_CasADi__FX___setOutput_TIC_TIC" c_CasADi__IOInterface_CasADi__FX___setOutput_TIC_TIC+ :: Ptr IOInterfaceFX' -> CDouble -> Ptr StdString' -> IO ()+casADi__IOInterface_CasADi__FX___setOutput''+ :: IOInterfaceFX -> Double -> String -> IO ()+casADi__IOInterface_CasADi__FX___setOutput'' x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__IOInterface_CasADi__FX___setOutput_TIC_TIC x0' x1' x2' >>= wrapReturn++-- classy wrapper+ioInterfaceFX_setOutput'' :: IOInterfaceFXClass a => a -> Double -> String -> IO ()+ioInterfaceFX_setOutput'' x = casADi__IOInterface_CasADi__FX___setOutput'' (castIOInterfaceFX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__IOInterface_CasADi__FX___setInput_TIC_TIC_TIC" c_CasADi__IOInterface_CasADi__FX___setInput_TIC_TIC_TIC+ :: Ptr IOInterfaceFX' -> Ptr (CppVec CDouble) -> CInt -> IO ()+casADi__IOInterface_CasADi__FX___setInput'''+ :: IOInterfaceFX -> Vector Double -> Int -> IO ()+casADi__IOInterface_CasADi__FX___setInput''' x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__IOInterface_CasADi__FX___setInput_TIC_TIC_TIC x0' x1' x2' >>= wrapReturn++-- classy wrapper+ioInterfaceFX_setInput''' :: IOInterfaceFXClass a => a -> Vector Double -> Int -> IO ()+ioInterfaceFX_setInput''' x = casADi__IOInterface_CasADi__FX___setInput''' (castIOInterfaceFX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__IOInterface_CasADi__FX___setInput_TIC_TIC_TIC_TIC" c_CasADi__IOInterface_CasADi__FX___setInput_TIC_TIC_TIC_TIC+ :: Ptr IOInterfaceFX' -> Ptr (CppVec CDouble) -> IO ()+casADi__IOInterface_CasADi__FX___setInput''''+ :: IOInterfaceFX -> Vector Double -> IO ()+casADi__IOInterface_CasADi__FX___setInput'''' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__IOInterface_CasADi__FX___setInput_TIC_TIC_TIC_TIC x0' x1' >>= wrapReturn++-- classy wrapper+ioInterfaceFX_setInput'''' :: IOInterfaceFXClass a => a -> Vector Double -> IO ()+ioInterfaceFX_setInput'''' x = casADi__IOInterface_CasADi__FX___setInput'''' (castIOInterfaceFX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__IOInterface_CasADi__FX___setOutput_TIC_TIC_TIC" c_CasADi__IOInterface_CasADi__FX___setOutput_TIC_TIC_TIC+ :: Ptr IOInterfaceFX' -> Ptr (CppVec CDouble) -> CInt -> IO ()+casADi__IOInterface_CasADi__FX___setOutput'''+ :: IOInterfaceFX -> Vector Double -> Int -> IO ()+casADi__IOInterface_CasADi__FX___setOutput''' x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__IOInterface_CasADi__FX___setOutput_TIC_TIC_TIC x0' x1' x2' >>= wrapReturn++-- classy wrapper+ioInterfaceFX_setOutput''' :: IOInterfaceFXClass a => a -> Vector Double -> Int -> IO ()+ioInterfaceFX_setOutput''' x = casADi__IOInterface_CasADi__FX___setOutput''' (castIOInterfaceFX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__IOInterface_CasADi__FX___setOutput_TIC_TIC_TIC_TIC" c_CasADi__IOInterface_CasADi__FX___setOutput_TIC_TIC_TIC_TIC+ :: Ptr IOInterfaceFX' -> Ptr (CppVec CDouble) -> IO ()+casADi__IOInterface_CasADi__FX___setOutput''''+ :: IOInterfaceFX -> Vector Double -> IO ()+casADi__IOInterface_CasADi__FX___setOutput'''' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__IOInterface_CasADi__FX___setOutput_TIC_TIC_TIC_TIC x0' x1' >>= wrapReturn++-- classy wrapper+ioInterfaceFX_setOutput'''' :: IOInterfaceFXClass a => a -> Vector Double -> IO ()+ioInterfaceFX_setOutput'''' x = casADi__IOInterface_CasADi__FX___setOutput'''' (castIOInterfaceFX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__IOInterface_CasADi__FX___setInput_TIC_TIC_TIC_TIC_TIC" c_CasADi__IOInterface_CasADi__FX___setInput_TIC_TIC_TIC_TIC_TIC+ :: Ptr IOInterfaceFX' -> Ptr (CppVec CDouble) -> Ptr StdString' -> IO ()+casADi__IOInterface_CasADi__FX___setInput'''''+ :: IOInterfaceFX -> Vector Double -> String -> IO ()+casADi__IOInterface_CasADi__FX___setInput''''' x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__IOInterface_CasADi__FX___setInput_TIC_TIC_TIC_TIC_TIC x0' x1' x2' >>= wrapReturn++-- classy wrapper+ioInterfaceFX_setInput''''' :: IOInterfaceFXClass a => a -> Vector Double -> String -> IO ()+ioInterfaceFX_setInput''''' x = casADi__IOInterface_CasADi__FX___setInput''''' (castIOInterfaceFX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__IOInterface_CasADi__FX___setOutput_TIC_TIC_TIC_TIC_TIC" c_CasADi__IOInterface_CasADi__FX___setOutput_TIC_TIC_TIC_TIC_TIC+ :: Ptr IOInterfaceFX' -> Ptr (CppVec CDouble) -> Ptr StdString' -> IO ()+casADi__IOInterface_CasADi__FX___setOutput'''''+ :: IOInterfaceFX -> Vector Double -> String -> IO ()+casADi__IOInterface_CasADi__FX___setOutput''''' x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__IOInterface_CasADi__FX___setOutput_TIC_TIC_TIC_TIC_TIC x0' x1' x2' >>= wrapReturn++-- classy wrapper+ioInterfaceFX_setOutput''''' :: IOInterfaceFXClass a => a -> Vector Double -> String -> IO ()+ioInterfaceFX_setOutput''''' x = casADi__IOInterface_CasADi__FX___setOutput''''' (castIOInterfaceFX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__IOInterface_CasADi__FX___setInput_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__IOInterface_CasADi__FX___setInput_TIC_TIC_TIC_TIC_TIC_TIC+ :: Ptr IOInterfaceFX' -> Ptr DMatrix' -> CInt -> IO ()+casADi__IOInterface_CasADi__FX___setInput''''''+ :: IOInterfaceFX -> DMatrix -> Int -> IO ()+casADi__IOInterface_CasADi__FX___setInput'''''' x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__IOInterface_CasADi__FX___setInput_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' >>= wrapReturn++-- classy wrapper+ioInterfaceFX_setInput'''''' :: IOInterfaceFXClass a => a -> DMatrix -> Int -> IO ()+ioInterfaceFX_setInput'''''' x = casADi__IOInterface_CasADi__FX___setInput'''''' (castIOInterfaceFX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__IOInterface_CasADi__FX___setInput_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__IOInterface_CasADi__FX___setInput_TIC_TIC_TIC_TIC_TIC_TIC_TIC+ :: Ptr IOInterfaceFX' -> Ptr DMatrix' -> IO ()+casADi__IOInterface_CasADi__FX___setInput'''''''+ :: IOInterfaceFX -> DMatrix -> IO ()+casADi__IOInterface_CasADi__FX___setInput''''''' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__IOInterface_CasADi__FX___setInput_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' >>= wrapReturn++-- classy wrapper+ioInterfaceFX_setInput''''''' :: IOInterfaceFXClass a => a -> DMatrix -> IO ()+ioInterfaceFX_setInput''''''' x = casADi__IOInterface_CasADi__FX___setInput''''''' (castIOInterfaceFX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__IOInterface_CasADi__FX___setOutput_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__IOInterface_CasADi__FX___setOutput_TIC_TIC_TIC_TIC_TIC_TIC+ :: Ptr IOInterfaceFX' -> Ptr DMatrix' -> CInt -> IO ()+casADi__IOInterface_CasADi__FX___setOutput''''''+ :: IOInterfaceFX -> DMatrix -> Int -> IO ()+casADi__IOInterface_CasADi__FX___setOutput'''''' x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__IOInterface_CasADi__FX___setOutput_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' >>= wrapReturn++-- classy wrapper+ioInterfaceFX_setOutput'''''' :: IOInterfaceFXClass a => a -> DMatrix -> Int -> IO ()+ioInterfaceFX_setOutput'''''' x = casADi__IOInterface_CasADi__FX___setOutput'''''' (castIOInterfaceFX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__IOInterface_CasADi__FX___setOutput_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__IOInterface_CasADi__FX___setOutput_TIC_TIC_TIC_TIC_TIC_TIC_TIC+ :: Ptr IOInterfaceFX' -> Ptr DMatrix' -> IO ()+casADi__IOInterface_CasADi__FX___setOutput'''''''+ :: IOInterfaceFX -> DMatrix -> IO ()+casADi__IOInterface_CasADi__FX___setOutput''''''' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__IOInterface_CasADi__FX___setOutput_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' >>= wrapReturn++-- classy wrapper+ioInterfaceFX_setOutput''''''' :: IOInterfaceFXClass a => a -> DMatrix -> IO ()+ioInterfaceFX_setOutput''''''' x = casADi__IOInterface_CasADi__FX___setOutput''''''' (castIOInterfaceFX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__IOInterface_CasADi__FX___setInput_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__IOInterface_CasADi__FX___setInput_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC+ :: Ptr IOInterfaceFX' -> Ptr DMatrix' -> Ptr StdString' -> IO ()+casADi__IOInterface_CasADi__FX___setInput''''''''+ :: IOInterfaceFX -> DMatrix -> String -> IO ()+casADi__IOInterface_CasADi__FX___setInput'''''''' x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__IOInterface_CasADi__FX___setInput_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' >>= wrapReturn++-- classy wrapper+ioInterfaceFX_setInput'''''''' :: IOInterfaceFXClass a => a -> DMatrix -> String -> IO ()+ioInterfaceFX_setInput'''''''' x = casADi__IOInterface_CasADi__FX___setInput'''''''' (castIOInterfaceFX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__IOInterface_CasADi__FX___setOutput_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__IOInterface_CasADi__FX___setOutput_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC+ :: Ptr IOInterfaceFX' -> Ptr DMatrix' -> Ptr StdString' -> IO ()+casADi__IOInterface_CasADi__FX___setOutput''''''''+ :: IOInterfaceFX -> DMatrix -> String -> IO ()+casADi__IOInterface_CasADi__FX___setOutput'''''''' x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__IOInterface_CasADi__FX___setOutput_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' >>= wrapReturn++-- classy wrapper+ioInterfaceFX_setOutput'''''''' :: IOInterfaceFXClass a => a -> DMatrix -> String -> IO ()+ioInterfaceFX_setOutput'''''''' x = casADi__IOInterface_CasADi__FX___setOutput'''''''' (castIOInterfaceFX x)+
+ Casadi/Wrappers/Classes/IOScheme.hs view
@@ -0,0 +1,336 @@+{-# OPTIONS_GHC -Wall #-}+{-# OPTIONS_GHC -fno-warn-unused-imports #-}+{-# OPTIONS_GHC -fno-warn-orphans #-}+{-# Language ForeignFunctionInterface #-}+{-# Language FlexibleInstances #-}+{-# Language MultiParamTypeClasses #-}++module Casadi.Wrappers.Classes.IOScheme+ (+ IOScheme,+ IOSchemeClass(..),+ ioScheme,+ ioScheme',+ ioScheme'',+ ioScheme_checkNode,+ ioScheme_compatibleSize,+ ioScheme_describe,+ ioScheme_describeInput,+ ioScheme_describeOutput,+ ioScheme_entry,+ ioScheme_entryEnum,+ ioScheme_entryLabel,+ ioScheme_entryNames,+ ioScheme_index,+ ioScheme_known,+ ioScheme_name,+ ioScheme_size,+ ) where+++import Prelude hiding ( Functor )++import Data.Vector ( Vector )+import Foreign.C.Types+import Foreign.Ptr ( Ptr )+import Foreign.ForeignPtr ( newForeignPtr )+import System.IO.Unsafe ( unsafePerformIO ) -- for show instances++import Casadi.Wrappers.Classes.PrintableObject+import Casadi.Wrappers.ForeignToolsInstances ( )+import Casadi.Wrappers.Deleters+import Casadi.Wrappers.Data+import Casadi.Wrappers.Enums+import Casadi.MarshalTypes ( CppVec, CppVecVec, CppVecVecVec,+ StdString', CppBool' ) -- StdOstream'+import Casadi.Marshal ( CornerCase(..), Marshal(..) )+import Casadi.WrapReturn ( WrapReturn(..) )++instance Show IOScheme where+ show = unsafePerformIO . printableObject_getDescription+-- direct wrapper+foreign import ccall unsafe "CasADi__IOScheme__checkNode" c_CasADi__IOScheme__checkNode+ :: Ptr IOScheme' -> IO (Ptr CppBool')+casADi__IOScheme__checkNode+ :: IOScheme -> IO Bool+casADi__IOScheme__checkNode x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__IOScheme__checkNode x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++-- classy wrapper+{-|+>Check if the node is pointing to the right type of object.+-}+ioScheme_checkNode :: IOSchemeClass a => a -> IO Bool+ioScheme_checkNode x = casADi__IOScheme__checkNode (castIOScheme x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__IOScheme__name" c_CasADi__IOScheme__name+ :: Ptr IOScheme' -> IO (Ptr StdString')+casADi__IOScheme__name+ :: IOScheme -> IO String+casADi__IOScheme__name x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__IOScheme__name x0' >>= (newForeignPtr c_delete_std__string) >>= wrapReturn++-- classy wrapper+{-|+>Name of the scheme.+-}+ioScheme_name :: IOSchemeClass a => a -> IO String+ioScheme_name x = casADi__IOScheme__name (castIOScheme x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__IOScheme__entryNames" c_CasADi__IOScheme__entryNames+ :: Ptr IOScheme' -> IO (Ptr StdString')+casADi__IOScheme__entryNames+ :: IOScheme -> IO String+casADi__IOScheme__entryNames x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__IOScheme__entryNames x0' >>= (newForeignPtr c_delete_std__string) >>= wrapReturn++-- classy wrapper+{-|+>List available entries.+-}+ioScheme_entryNames :: IOSchemeClass a => a -> IO String+ioScheme_entryNames x = casADi__IOScheme__entryNames (castIOScheme x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__IOScheme__index" c_CasADi__IOScheme__index+ :: Ptr IOScheme' -> Ptr StdString' -> IO CInt+casADi__IOScheme__index+ :: IOScheme -> String -> IO Int+casADi__IOScheme__index x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__IOScheme__index x0' x1' >>= wrapReturn++-- classy wrapper+{-|+>Get index by entry name.+-}+ioScheme_index :: IOSchemeClass a => a -> String -> IO Int+ioScheme_index x = casADi__IOScheme__index (castIOScheme x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__IOScheme__size" c_CasADi__IOScheme__size+ :: Ptr IOScheme' -> IO CInt+casADi__IOScheme__size+ :: IOScheme -> IO Int+casADi__IOScheme__size x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__IOScheme__size x0' >>= wrapReturn++-- classy wrapper+{-|+>Number of entries.+-}+ioScheme_size :: IOSchemeClass a => a -> IO Int+ioScheme_size x = casADi__IOScheme__size (castIOScheme x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__IOScheme__entry" c_CasADi__IOScheme__entry+ :: Ptr IOScheme' -> CInt -> IO (Ptr StdString')+casADi__IOScheme__entry+ :: IOScheme -> Int -> IO String+casADi__IOScheme__entry x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__IOScheme__entry x0' x1' >>= (newForeignPtr c_delete_std__string) >>= wrapReturn++-- classy wrapper+{-|+>Get the entry name by index.+-}+ioScheme_entry :: IOSchemeClass a => a -> Int -> IO String+ioScheme_entry x = casADi__IOScheme__entry (castIOScheme x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__IOScheme__entryLabel" c_CasADi__IOScheme__entryLabel+ :: Ptr IOScheme' -> CInt -> IO (Ptr StdString')+casADi__IOScheme__entryLabel+ :: IOScheme -> Int -> IO String+casADi__IOScheme__entryLabel x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__IOScheme__entryLabel x0' x1' >>= (newForeignPtr c_delete_std__string) >>= wrapReturn++-- classy wrapper+{-|+>Get the entry label by index If scheme is unknown, returns the index as a+>string.+-}+ioScheme_entryLabel :: IOSchemeClass a => a -> Int -> IO String+ioScheme_entryLabel x = casADi__IOScheme__entryLabel (castIOScheme x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__IOScheme__entryEnum" c_CasADi__IOScheme__entryEnum+ :: Ptr IOScheme' -> CInt -> IO (Ptr StdString')+casADi__IOScheme__entryEnum+ :: IOScheme -> Int -> IO String+casADi__IOScheme__entryEnum x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__IOScheme__entryEnum x0' x1' >>= (newForeignPtr c_delete_std__string) >>= wrapReturn++-- classy wrapper+{-|+>Get the entry enum name by index.+-}+ioScheme_entryEnum :: IOSchemeClass a => a -> Int -> IO String+ioScheme_entryEnum x = casADi__IOScheme__entryEnum (castIOScheme x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__IOScheme__describeInput" c_CasADi__IOScheme__describeInput+ :: Ptr IOScheme' -> CInt -> IO (Ptr StdString')+casADi__IOScheme__describeInput+ :: IOScheme -> Int -> IO String+casADi__IOScheme__describeInput x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__IOScheme__describeInput x0' x1' >>= (newForeignPtr c_delete_std__string) >>= wrapReturn++-- classy wrapper+{-|+>Describe the index as an input.+-}+ioScheme_describeInput :: IOSchemeClass a => a -> Int -> IO String+ioScheme_describeInput x = casADi__IOScheme__describeInput (castIOScheme x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__IOScheme__describeOutput" c_CasADi__IOScheme__describeOutput+ :: Ptr IOScheme' -> CInt -> IO (Ptr StdString')+casADi__IOScheme__describeOutput+ :: IOScheme -> Int -> IO String+casADi__IOScheme__describeOutput x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__IOScheme__describeOutput x0' x1' >>= (newForeignPtr c_delete_std__string) >>= wrapReturn++-- classy wrapper+{-|+>Describe the index as an output.+-}+ioScheme_describeOutput :: IOSchemeClass a => a -> Int -> IO String+ioScheme_describeOutput x = casADi__IOScheme__describeOutput (castIOScheme x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__IOScheme__describe" c_CasADi__IOScheme__describe+ :: Ptr IOScheme' -> CInt -> IO (Ptr StdString')+casADi__IOScheme__describe+ :: IOScheme -> Int -> IO String+casADi__IOScheme__describe x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__IOScheme__describe x0' x1' >>= (newForeignPtr c_delete_std__string) >>= wrapReturn++-- classy wrapper+{-|+>Describe the index.+-}+ioScheme_describe :: IOSchemeClass a => a -> Int -> IO String+ioScheme_describe x = casADi__IOScheme__describe (castIOScheme x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__IOScheme__known" c_CasADi__IOScheme__known+ :: Ptr IOScheme' -> IO (Ptr CppBool')+casADi__IOScheme__known+ :: IOScheme -> IO Bool+casADi__IOScheme__known x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__IOScheme__known x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++-- classy wrapper+{-|+>Check wether the scheme is known.+-}+ioScheme_known :: IOSchemeClass a => a -> IO Bool+ioScheme_known x = casADi__IOScheme__known (castIOScheme x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__IOScheme__compatibleSize" c_CasADi__IOScheme__compatibleSize+ :: Ptr IOScheme' -> CInt -> IO CInt+casADi__IOScheme__compatibleSize+ :: IOScheme -> Int -> IO Int+casADi__IOScheme__compatibleSize x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__IOScheme__compatibleSize x0' x1' >>= wrapReturn++-- classy wrapper+{-|+>Check wether this scheme is compatible with the given size.+-}+ioScheme_compatibleSize :: IOSchemeClass a => a -> Int -> IO Int+ioScheme_compatibleSize x = casADi__IOScheme__compatibleSize (castIOScheme x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__IOScheme__IOScheme" c_CasADi__IOScheme__IOScheme+ :: IO (Ptr IOScheme')+casADi__IOScheme__IOScheme+ :: IO IOScheme+casADi__IOScheme__IOScheme =+ c_CasADi__IOScheme__IOScheme >>= (newForeignPtr c_delete_CasADi__IOScheme) >>= wrapReturn++-- classy wrapper+{-|+>> CasADi::IOScheme::IOScheme()+>------------------------------------------------------------------------+>+>Default constructor.+>+>> CasADi::IOScheme::IOScheme(InputOutputScheme scheme)+>------------------------------------------------------------------------+>+>Constructor with enum.+>+>> CasADi::IOScheme::IOScheme(const std::vector< std::string > &entries)+>------------------------------------------------------------------------+>+>Constructor with entry names.+-}+ioScheme :: IO IOScheme+ioScheme = casADi__IOScheme__IOScheme+++-- direct wrapper+foreign import ccall unsafe "CasADi__IOScheme__IOScheme_TIC" c_CasADi__IOScheme__IOScheme_TIC+ :: CInt -> IO (Ptr IOScheme')+casADi__IOScheme__IOScheme'+ :: InputOutputScheme -> IO IOScheme+casADi__IOScheme__IOScheme' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__IOScheme__IOScheme_TIC x0' >>= (newForeignPtr c_delete_CasADi__IOScheme) >>= wrapReturn++-- classy wrapper+ioScheme' :: InputOutputScheme -> IO IOScheme+ioScheme' = casADi__IOScheme__IOScheme'+++-- direct wrapper+foreign import ccall unsafe "CasADi__IOScheme__IOScheme_TIC_TIC" c_CasADi__IOScheme__IOScheme_TIC_TIC+ :: Ptr (CppVec (Ptr StdString')) -> IO (Ptr IOScheme')+casADi__IOScheme__IOScheme''+ :: Vector String -> IO IOScheme+casADi__IOScheme__IOScheme'' x0 =+ withMarshal (CornerCase x0) $ \x0' ->+ c_CasADi__IOScheme__IOScheme_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__IOScheme) >>= wrapReturn++-- classy wrapper+ioScheme'' :: Vector String -> IO IOScheme+ioScheme'' = casADi__IOScheme__IOScheme''+
+ Casadi/Wrappers/Classes/IpoptSolver.hs view
@@ -0,0 +1,131 @@+{-# OPTIONS_GHC -Wall #-}+{-# OPTIONS_GHC -fno-warn-unused-imports #-}+{-# OPTIONS_GHC -fno-warn-orphans #-}+{-# Language ForeignFunctionInterface #-}+{-# Language FlexibleInstances #-}+{-# Language MultiParamTypeClasses #-}++module Casadi.Wrappers.Classes.IpoptSolver+ (+ IpoptSolver,+ IpoptSolverClass(..),+ ipoptSolver,+ ipoptSolver',+ ipoptSolver'',+ ipoptSolver_checkNode,+ ipoptSolver_getReducedHessian,+ ) where+++import Prelude hiding ( Functor )++import Data.Vector ( Vector )+import Foreign.C.Types+import Foreign.Ptr ( Ptr )+import Foreign.ForeignPtr ( newForeignPtr )+import System.IO.Unsafe ( unsafePerformIO ) -- for show instances++import Casadi.Wrappers.Classes.PrintableObject+import Casadi.Wrappers.ForeignToolsInstances ( )+import Casadi.Wrappers.Deleters+import Casadi.Wrappers.Data+import Casadi.Wrappers.Enums+import Casadi.MarshalTypes ( CppVec, CppVecVec, CppVecVecVec,+ StdString', CppBool' ) -- StdOstream'+import Casadi.Marshal ( CornerCase(..), Marshal(..) )+import Casadi.WrapReturn ( WrapReturn(..) )++instance Show IpoptSolver where+ show = unsafePerformIO . printableObject_getDescription+-- direct wrapper+foreign import ccall unsafe "CasADi__IpoptSolver__getReducedHessian" c_CasADi__IpoptSolver__getReducedHessian+ :: Ptr IpoptSolver' -> IO (Ptr DMatrix')+casADi__IpoptSolver__getReducedHessian+ :: IpoptSolver -> IO DMatrix+casADi__IpoptSolver__getReducedHessian x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__IpoptSolver__getReducedHessian x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++-- classy wrapper+{-|+>Get the reduced Hessian. Requires a patched sIPOPT installation, see CasADi+>documentation.+-}+ipoptSolver_getReducedHessian :: IpoptSolverClass a => a -> IO DMatrix+ipoptSolver_getReducedHessian x = casADi__IpoptSolver__getReducedHessian (castIpoptSolver x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__IpoptSolver__checkNode" c_CasADi__IpoptSolver__checkNode+ :: Ptr IpoptSolver' -> IO (Ptr CppBool')+casADi__IpoptSolver__checkNode+ :: IpoptSolver -> IO Bool+casADi__IpoptSolver__checkNode x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__IpoptSolver__checkNode x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++-- classy wrapper+{-|+>Check if the node is pointing to the right type of object.+-}+ipoptSolver_checkNode :: IpoptSolverClass a => a -> IO Bool+ipoptSolver_checkNode x = casADi__IpoptSolver__checkNode (castIpoptSolver x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__IpoptSolver__IpoptSolver" c_CasADi__IpoptSolver__IpoptSolver+ :: IO (Ptr IpoptSolver')+casADi__IpoptSolver__IpoptSolver+ :: IO IpoptSolver+casADi__IpoptSolver__IpoptSolver =+ c_CasADi__IpoptSolver__IpoptSolver >>= (newForeignPtr c_delete_CasADi__IpoptSolver) >>= wrapReturn++-- classy wrapper+{-|+>> CasADi::IpoptSolver::IpoptSolver()+>------------------------------------------------------------------------+>+>Default constructor.+>+>> CasADi::IpoptSolver::IpoptSolver(const FX &F, const FX &G)+>------------------------------------------------------------------------+>+>Create an NLP solver instance (legacy syntax)+>+>> CasADi::IpoptSolver::IpoptSolver(const FX &nlp)+>------------------------------------------------------------------------+>+>Create an NLP solver instance.+-}+ipoptSolver :: IO IpoptSolver+ipoptSolver = casADi__IpoptSolver__IpoptSolver+++-- direct wrapper+foreign import ccall unsafe "CasADi__IpoptSolver__IpoptSolver_TIC" c_CasADi__IpoptSolver__IpoptSolver_TIC+ :: Ptr FX' -> Ptr FX' -> IO (Ptr IpoptSolver')+casADi__IpoptSolver__IpoptSolver'+ :: FX -> FX -> IO IpoptSolver+casADi__IpoptSolver__IpoptSolver' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__IpoptSolver__IpoptSolver_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__IpoptSolver) >>= wrapReturn++-- classy wrapper+ipoptSolver' :: FX -> FX -> IO IpoptSolver+ipoptSolver' = casADi__IpoptSolver__IpoptSolver'+++-- direct wrapper+foreign import ccall unsafe "CasADi__IpoptSolver__IpoptSolver_TIC_TIC" c_CasADi__IpoptSolver__IpoptSolver_TIC_TIC+ :: Ptr FX' -> IO (Ptr IpoptSolver')+casADi__IpoptSolver__IpoptSolver''+ :: FX -> IO IpoptSolver+casADi__IpoptSolver__IpoptSolver'' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__IpoptSolver__IpoptSolver_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__IpoptSolver) >>= wrapReturn++-- classy wrapper+ipoptSolver'' :: FX -> IO IpoptSolver+ipoptSolver'' = casADi__IpoptSolver__IpoptSolver''+
+ Casadi/Wrappers/Classes/MX.hs view
@@ -0,0 +1,2327 @@+{-# OPTIONS_GHC -Wall #-}+{-# OPTIONS_GHC -fno-warn-unused-imports #-}+{-# OPTIONS_GHC -fno-warn-orphans #-}+{-# Language ForeignFunctionInterface #-}+{-# Language FlexibleInstances #-}+{-# Language MultiParamTypeClasses #-}++module Casadi.Wrappers.Classes.MX+ (+ MX,+ MXClass(..),+ mx,+ mx',+ mx'',+ mx''',+ mx'''',+ mx''''',+ mx'''''',+ mx''''''',+ mx'''''''',+ mx''''''''',+ mx'''''''''',+ mx''''''''''',+ mx'''''''''''',+ mx___add__,+ mx___constpow__,+ mx___div__,+ mx___eq__,+ mx___hash__,+ mx___le__,+ mx___lt__,+ mx___mpower__,+ mx___mrdivide__,+ mx___mul__,+ mx___ne__,+ mx___nonzero__,+ mx___pow__,+ mx___sub__,+ mx___truediv__,+ mx_append,+ mx_arccos,+ mx_arccosh,+ mx_arcsin,+ mx_arcsinh,+ mx_arctan,+ mx_arctan2,+ mx_arctanh,+ mx_attachAssert,+ mx_attachAssert',+ mx_binary,+ mx_ceil,+ mx_constpow,+ mx_cos,+ mx_cosh,+ mx_enlarge,+ mx_erase,+ mx_erf,+ mx_erfinv,+ mx_exp,+ mx_eye,+ mx_fabs,+ mx_floor,+ mx_fmax,+ mx_fmin,+ mx_getDep,+ mx_getDep',+ mx_getEqualityCheckingDepth,+ mx_getEvaluationOutput,+ mx_getFunction,+ mx_getMatrixValue,+ mx_getMaxNumCallsInPrint,+ mx_getNZ,+ mx_getNZ',+ mx_getName,+ mx_getNdeps,+ mx_getNumOutputs,+ mx_getOp,+ mx_getOutput,+ mx_getOutput',+ mx_getTemp,+ mx_getValue,+ mx_if_else_zero,+ mx_inf,+ mx_inf',+ mx_inf'',+ mx_inf''',+ mx_inner_prod,+ mx_isBinary,+ mx_isCommutative,+ mx_isConstant,+ mx_isEqual,+ mx_isEqual',+ mx_isEvaluation,+ mx_isEvaluationOutput,+ mx_isMultiplication,+ mx_isNorm,+ mx_isOperation,+ mx_isSymbolic,+ mx_isUnary,+ mx_lift,+ mx_log,+ mx_log10,+ mx_logic_and,+ mx_logic_not,+ mx_logic_or,+ mx_makeDense,+ mx_makeDense',+ mx_mul,+ mx_mul',+ mx_mul_full,+ mx_mul_full',+ mx_nan,+ mx_nan',+ mx_nan'',+ mx_nan''',+ mx_numel,+ mx_ones,+ mx_ones',+ mx_ones'',+ mx_operator_minus,+ mx_outer_prod,+ mx_printme,+ mx_repmat,+ mx_repmat',+ mx_setEqualityCheckingDepth,+ mx_setEqualityCheckingDepth',+ mx_setMaxNumCallsInPrint,+ mx_setMaxNumCallsInPrint',+ mx_setSparse,+ mx_setSparse',+ mx_setTemp,+ mx_sign,+ mx_sin,+ mx_sinh,+ mx_size,+ mx_size1,+ mx_size2,+ mx_sparse,+ mx_sparse',+ mx_sparsityRef,+ mx_sqrt,+ mx_tan,+ mx_tanh,+ mx_unary,+ mx_zeros,+ mx_zeros',+ mx_zeros'',+ ) where+++import Prelude hiding ( Functor )++import Data.Vector ( Vector )+import Foreign.C.Types+import Foreign.Ptr ( Ptr )+import Foreign.ForeignPtr ( newForeignPtr )+import System.IO.Unsafe ( unsafePerformIO ) -- for show instances++import Casadi.Wrappers.Classes.PrintableObject+import Casadi.Wrappers.ForeignToolsInstances ( )+import Casadi.Wrappers.Deleters+import Casadi.Wrappers.Data+import Casadi.Wrappers.Enums+import Casadi.MarshalTypes ( CppVec, CppVecVec, CppVecVecVec,+ StdString', CppBool' ) -- StdOstream'+import Casadi.Marshal ( CornerCase(..), Marshal(..) )+import Casadi.WrapReturn ( WrapReturn(..) )++instance Show MX where+ show = unsafePerformIO . printableObject_getDescription+-- direct wrapper+foreign import ccall unsafe "CasADi__MX__size1" c_CasADi__MX__size1+ :: Ptr MX' -> IO CInt+casADi__MX__size1+ :: MX -> IO Int+casADi__MX__size1 x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__MX__size1 x0' >>= wrapReturn++-- classy wrapper+mx_size1 :: MXClass a => a -> IO Int+mx_size1 x = casADi__MX__size1 (castMX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__size2" c_CasADi__MX__size2+ :: Ptr MX' -> IO CInt+casADi__MX__size2+ :: MX -> IO Int+casADi__MX__size2 x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__MX__size2 x0' >>= wrapReturn++-- classy wrapper+mx_size2 :: MXClass a => a -> IO Int+mx_size2 x = casADi__MX__size2 (castMX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__size" c_CasADi__MX__size+ :: Ptr MX' -> IO CInt+casADi__MX__size+ :: MX -> IO Int+casADi__MX__size x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__MX__size x0' >>= wrapReturn++-- classy wrapper+mx_size :: MXClass a => a -> IO Int+mx_size x = casADi__MX__size (castMX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__numel" c_CasADi__MX__numel+ :: Ptr MX' -> IO CInt+casADi__MX__numel+ :: MX -> IO Int+casADi__MX__numel x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__MX__numel x0' >>= wrapReturn++-- classy wrapper+mx_numel :: MXClass a => a -> IO Int+mx_numel x = casADi__MX__numel (castMX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX____nonzero__" c_CasADi__MX____nonzero__+ :: Ptr MX' -> IO (Ptr CppBool')+casADi__MX____nonzero__+ :: MX -> IO Bool+casADi__MX____nonzero__ x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__MX____nonzero__ x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++-- classy wrapper+{-|+>Returns the truth value of an MX expression.+-}+mx___nonzero__ :: MXClass a => a -> IO Bool+mx___nonzero__ x = casADi__MX____nonzero__ (castMX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__sparsityRef" c_CasADi__MX__sparsityRef+ :: Ptr MX' -> IO (Ptr CRSSparsity')+casADi__MX__sparsityRef+ :: MX -> IO CRSSparsity+casADi__MX__sparsityRef x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__MX__sparsityRef x0' >>= (newForeignPtr c_delete_CasADi__CRSSparsity) >>= wrapReturn++-- classy wrapper+{-|+>Access the sparsity, make a copy if there are multiple references to it.+-}+mx_sparsityRef :: MXClass a => a -> IO CRSSparsity+mx_sparsityRef x = casADi__MX__sparsityRef (castMX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__erase" c_CasADi__MX__erase+ :: Ptr MX' -> Ptr (CppVec CInt) -> Ptr (CppVec CInt) -> IO ()+casADi__MX__erase+ :: MX -> Vector Int -> Vector Int -> IO ()+casADi__MX__erase x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__MX__erase x0' x1' x2' >>= wrapReturn++-- classy wrapper+{-|+>Erase a submatrix.+-}+mx_erase :: MXClass a => a -> Vector Int -> Vector Int -> IO ()+mx_erase x = casADi__MX__erase (castMX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__enlarge" c_CasADi__MX__enlarge+ :: Ptr MX' -> CInt -> CInt -> Ptr (CppVec CInt) -> Ptr (CppVec CInt) -> IO ()+casADi__MX__enlarge+ :: MX -> Int -> Int -> Vector Int -> Vector Int -> IO ()+casADi__MX__enlarge x0 x1 x2 x3 x4 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ withMarshal x3 $ \x3' ->+ withMarshal x4 $ \x4' ->+ c_CasADi__MX__enlarge x0' x1' x2' x3' x4' >>= wrapReturn++-- classy wrapper+{-|+>Enlarge matrix Make the matrix larger by inserting empty rows and columns,+>keeping the existing non-zeros.+-}+mx_enlarge :: MXClass a => a -> Int -> Int -> Vector Int -> Vector Int -> IO ()+mx_enlarge x = casADi__MX__enlarge (castMX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__operator_minus" c_CasADi__MX__operator_minus+ :: Ptr MX' -> IO (Ptr MX')+casADi__MX__operator_minus+ :: MX -> IO MX+casADi__MX__operator_minus x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__MX__operator_minus x0' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++-- classy wrapper+mx_operator_minus :: MXClass a => a -> IO MX+mx_operator_minus x = casADi__MX__operator_minus (castMX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__getDep" c_CasADi__MX__getDep+ :: Ptr MX' -> CInt -> IO (Ptr MX')+casADi__MX__getDep+ :: MX -> Int -> IO MX+casADi__MX__getDep x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__MX__getDep x0' x1' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++-- classy wrapper+{-|+>Get the nth dependency as MX.+-}+mx_getDep :: MXClass a => a -> Int -> IO MX+mx_getDep x = casADi__MX__getDep (castMX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__getDep_TIC" c_CasADi__MX__getDep_TIC+ :: Ptr MX' -> IO (Ptr MX')+casADi__MX__getDep'+ :: MX -> IO MX+casADi__MX__getDep' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__MX__getDep_TIC x0' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++-- classy wrapper+mx_getDep' :: MXClass a => a -> IO MX+mx_getDep' x = casADi__MX__getDep' (castMX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__getNumOutputs" c_CasADi__MX__getNumOutputs+ :: Ptr MX' -> IO CInt+casADi__MX__getNumOutputs+ :: MX -> IO Int+casADi__MX__getNumOutputs x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__MX__getNumOutputs x0' >>= wrapReturn++-- classy wrapper+{-|+>Number of outputs.+-}+mx_getNumOutputs :: MXClass a => a -> IO Int+mx_getNumOutputs x = casADi__MX__getNumOutputs (castMX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__getOutput" c_CasADi__MX__getOutput+ :: Ptr MX' -> CInt -> IO (Ptr MX')+casADi__MX__getOutput+ :: MX -> Int -> IO MX+casADi__MX__getOutput x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__MX__getOutput x0' x1' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++-- classy wrapper+{-|+>Get an output.+-}+mx_getOutput :: MXClass a => a -> Int -> IO MX+mx_getOutput x = casADi__MX__getOutput (castMX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__getOutput_TIC" c_CasADi__MX__getOutput_TIC+ :: Ptr MX' -> IO (Ptr MX')+casADi__MX__getOutput'+ :: MX -> IO MX+casADi__MX__getOutput' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__MX__getOutput_TIC x0' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++-- classy wrapper+mx_getOutput' :: MXClass a => a -> IO MX+mx_getOutput' x = casADi__MX__getOutput' (castMX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__getNdeps" c_CasADi__MX__getNdeps+ :: Ptr MX' -> IO CInt+casADi__MX__getNdeps+ :: MX -> IO Int+casADi__MX__getNdeps x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__MX__getNdeps x0' >>= wrapReturn++-- classy wrapper+{-|+>Get the number of dependencies of a binary SX.+-}+mx_getNdeps :: MXClass a => a -> IO Int+mx_getNdeps x = casADi__MX__getNdeps (castMX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__getName" c_CasADi__MX__getName+ :: Ptr MX' -> IO (Ptr StdString')+casADi__MX__getName+ :: MX -> IO String+casADi__MX__getName x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__MX__getName x0' >>= (newForeignPtr c_delete_std__string) >>= wrapReturn++-- classy wrapper+{-|+>Get the name.+-}+mx_getName :: MXClass a => a -> IO String+mx_getName x = casADi__MX__getName (castMX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__getValue" c_CasADi__MX__getValue+ :: Ptr MX' -> IO CDouble+casADi__MX__getValue+ :: MX -> IO Double+casADi__MX__getValue x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__MX__getValue x0' >>= wrapReturn++-- classy wrapper+{-|+>Get the value (only for scalar constant nodes)+-}+mx_getValue :: MXClass a => a -> IO Double+mx_getValue x = casADi__MX__getValue (castMX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__getMatrixValue" c_CasADi__MX__getMatrixValue+ :: Ptr MX' -> IO (Ptr DMatrix')+casADi__MX__getMatrixValue+ :: MX -> IO DMatrix+casADi__MX__getMatrixValue x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__MX__getMatrixValue x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++-- classy wrapper+{-|+>Get the value (only for constant nodes)+-}+mx_getMatrixValue :: MXClass a => a -> IO DMatrix+mx_getMatrixValue x = casADi__MX__getMatrixValue (castMX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__isSymbolic" c_CasADi__MX__isSymbolic+ :: Ptr MX' -> IO (Ptr CppBool')+casADi__MX__isSymbolic+ :: MX -> IO Bool+casADi__MX__isSymbolic x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__MX__isSymbolic x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++-- classy wrapper+{-|+>Check if symbolic.+-}+mx_isSymbolic :: MXClass a => a -> IO Bool+mx_isSymbolic x = casADi__MX__isSymbolic (castMX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__isConstant" c_CasADi__MX__isConstant+ :: Ptr MX' -> IO (Ptr CppBool')+casADi__MX__isConstant+ :: MX -> IO Bool+casADi__MX__isConstant x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__MX__isConstant x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++-- classy wrapper+{-|+>Check if constant.+-}+mx_isConstant :: MXClass a => a -> IO Bool+mx_isConstant x = casADi__MX__isConstant (castMX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__isEvaluation" c_CasADi__MX__isEvaluation+ :: Ptr MX' -> IO (Ptr CppBool')+casADi__MX__isEvaluation+ :: MX -> IO Bool+casADi__MX__isEvaluation x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__MX__isEvaluation x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++-- classy wrapper+{-|+>Check if evaluation.+-}+mx_isEvaluation :: MXClass a => a -> IO Bool+mx_isEvaluation x = casADi__MX__isEvaluation (castMX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__isEvaluationOutput" c_CasADi__MX__isEvaluationOutput+ :: Ptr MX' -> IO (Ptr CppBool')+casADi__MX__isEvaluationOutput+ :: MX -> IO Bool+casADi__MX__isEvaluationOutput x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__MX__isEvaluationOutput x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++-- classy wrapper+{-|+>Check if evaluation output.+-}+mx_isEvaluationOutput :: MXClass a => a -> IO Bool+mx_isEvaluationOutput x = casADi__MX__isEvaluationOutput (castMX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__getEvaluationOutput" c_CasADi__MX__getEvaluationOutput+ :: Ptr MX' -> IO CInt+casADi__MX__getEvaluationOutput+ :: MX -> IO Int+casADi__MX__getEvaluationOutput x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__MX__getEvaluationOutput x0' >>= wrapReturn++-- classy wrapper+{-|+>Get the index of evaluation output - only valid when isEvaluationoutput() is+>true.+-}+mx_getEvaluationOutput :: MXClass a => a -> IO Int+mx_getEvaluationOutput x = casADi__MX__getEvaluationOutput (castMX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__isOperation" c_CasADi__MX__isOperation+ :: Ptr MX' -> CInt -> IO (Ptr CppBool')+casADi__MX__isOperation+ :: MX -> Int -> IO Bool+casADi__MX__isOperation x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__MX__isOperation x0' x1' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++-- classy wrapper+{-|+>Is it a certain operation.+-}+mx_isOperation :: MXClass a => a -> Int -> IO Bool+mx_isOperation x = casADi__MX__isOperation (castMX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__isMultiplication" c_CasADi__MX__isMultiplication+ :: Ptr MX' -> IO (Ptr CppBool')+casADi__MX__isMultiplication+ :: MX -> IO Bool+casADi__MX__isMultiplication x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__MX__isMultiplication x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++-- classy wrapper+{-|+>Check if multiplication.+-}+mx_isMultiplication :: MXClass a => a -> IO Bool+mx_isMultiplication x = casADi__MX__isMultiplication (castMX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__isCommutative" c_CasADi__MX__isCommutative+ :: Ptr MX' -> IO (Ptr CppBool')+casADi__MX__isCommutative+ :: MX -> IO Bool+casADi__MX__isCommutative x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__MX__isCommutative x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++-- classy wrapper+{-|+>Check if commutative operation.+-}+mx_isCommutative :: MXClass a => a -> IO Bool+mx_isCommutative x = casADi__MX__isCommutative (castMX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__isNorm" c_CasADi__MX__isNorm+ :: Ptr MX' -> IO (Ptr CppBool')+casADi__MX__isNorm+ :: MX -> IO Bool+casADi__MX__isNorm x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__MX__isNorm x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++-- classy wrapper+{-|+>Check if norm.+-}+mx_isNorm :: MXClass a => a -> IO Bool+mx_isNorm x = casADi__MX__isNorm (castMX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__getFunction" c_CasADi__MX__getFunction+ :: Ptr MX' -> IO (Ptr FX')+casADi__MX__getFunction+ :: MX -> IO FX+casADi__MX__getFunction x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__MX__getFunction x0' >>= (newForeignPtr c_delete_CasADi__FX) >>= wrapReturn++-- classy wrapper+{-|+>Get function.+-}+mx_getFunction :: MXClass a => a -> IO FX+mx_getFunction x = casADi__MX__getFunction (castMX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__isBinary" c_CasADi__MX__isBinary+ :: Ptr MX' -> IO (Ptr CppBool')+casADi__MX__isBinary+ :: MX -> IO Bool+casADi__MX__isBinary x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__MX__isBinary x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++-- classy wrapper+{-|+>Is binary operation.+-}+mx_isBinary :: MXClass a => a -> IO Bool+mx_isBinary x = casADi__MX__isBinary (castMX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__isUnary" c_CasADi__MX__isUnary+ :: Ptr MX' -> IO (Ptr CppBool')+casADi__MX__isUnary+ :: MX -> IO Bool+casADi__MX__isUnary x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__MX__isUnary x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++-- classy wrapper+{-|+>Is unary operation.+-}+mx_isUnary :: MXClass a => a -> IO Bool+mx_isUnary x = casADi__MX__isUnary (castMX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__getOp" c_CasADi__MX__getOp+ :: Ptr MX' -> IO CInt+casADi__MX__getOp+ :: MX -> IO Int+casADi__MX__getOp x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__MX__getOp x0' >>= wrapReturn++-- classy wrapper+{-|+>Get operation type.+-}+mx_getOp :: MXClass a => a -> IO Int+mx_getOp x = casADi__MX__getOp (castMX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__isEqual" c_CasADi__MX__isEqual+ :: Ptr MX' -> Ptr MX' -> CInt -> IO (Ptr CppBool')+casADi__MX__isEqual+ :: MX -> MX -> Int -> IO Bool+casADi__MX__isEqual x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__MX__isEqual x0' x1' x2' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++-- classy wrapper+{-|+>> bool CasADi::MX::isEqual(const MX &y, int depth=0) const +>------------------------------------------------------------------------+>+>Check if two nodes are equivalent up to a given depth. Depth=0 checks if the+>expressions are identical, i.e. points to the same node.+>+>a = x*x b = x*x+>+>a.isEqual(b,0) will return false, but a.isEqual(b,1) will return true+-}+mx_isEqual :: MXClass a => a -> MX -> Int -> IO Bool+mx_isEqual x = casADi__MX__isEqual (castMX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__isEqual_TIC" c_CasADi__MX__isEqual_TIC+ :: Ptr MX' -> Ptr MX' -> IO (Ptr CppBool')+casADi__MX__isEqual'+ :: MX -> MX -> IO Bool+casADi__MX__isEqual' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__MX__isEqual_TIC x0' x1' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++-- classy wrapper+mx_isEqual' :: MXClass a => a -> MX -> IO Bool+mx_isEqual' x = casADi__MX__isEqual' (castMX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX____hash__" c_CasADi__MX____hash__+ :: Ptr MX' -> IO CLong+casADi__MX____hash__+ :: MX -> IO Int+casADi__MX____hash__ x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__MX____hash__ x0' >>= wrapReturn++-- classy wrapper+{-|+>Returns a number that is unique for a given MXNode. If the MX does not point+>to any node, 0 is returned.+-}+mx___hash__ :: MXClass a => a -> IO Int+mx___hash__ x = casADi__MX____hash__ (castMX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__getTemp" c_CasADi__MX__getTemp+ :: Ptr MX' -> IO CInt+casADi__MX__getTemp+ :: MX -> IO Int+casADi__MX__getTemp x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__MX__getTemp x0' >>= wrapReturn++-- classy wrapper+{-|+>Get the temporary variable.+-}+mx_getTemp :: MXClass a => a -> IO Int+mx_getTemp x = casADi__MX__getTemp (castMX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__setTemp" c_CasADi__MX__setTemp+ :: Ptr MX' -> CInt -> IO ()+casADi__MX__setTemp+ :: MX -> Int -> IO ()+casADi__MX__setTemp x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__MX__setTemp x0' x1' >>= wrapReturn++-- classy wrapper+{-|+>Set the temporary variable.+-}+mx_setTemp :: MXClass a => a -> Int -> IO ()+mx_setTemp x = casADi__MX__setTemp (castMX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__binary" c_CasADi__MX__binary+ :: CInt -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')+casADi__MX__binary+ :: Int -> MX -> MX -> IO MX+casADi__MX__binary x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__MX__binary x0' x1' x2' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++-- classy wrapper+{-|+>Create nodes by their ID.+-}+mx_binary :: Int -> MX -> MX -> IO MX+mx_binary = casADi__MX__binary+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__unary" c_CasADi__MX__unary+ :: CInt -> Ptr MX' -> IO (Ptr MX')+casADi__MX__unary+ :: Int -> MX -> IO MX+casADi__MX__unary x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__MX__unary x0' x1' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++-- classy wrapper+{-|+>Create nodes by their ID.+-}+mx_unary :: Int -> MX -> IO MX+mx_unary = casADi__MX__unary+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__sparse" c_CasADi__MX__sparse+ :: CInt -> CInt -> IO (Ptr MX')+casADi__MX__sparse+ :: Int -> Int -> IO MX+casADi__MX__sparse x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__MX__sparse x0' x1' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++-- classy wrapper+{-|+>Sparse matrix of all zeros.+-}+mx_sparse :: Int -> Int -> IO MX+mx_sparse = casADi__MX__sparse+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__sparse_TIC" c_CasADi__MX__sparse_TIC+ :: CInt -> IO (Ptr MX')+casADi__MX__sparse'+ :: Int -> IO MX+casADi__MX__sparse' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__MX__sparse_TIC x0' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++-- classy wrapper+mx_sparse' :: Int -> IO MX+mx_sparse' = casADi__MX__sparse'+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__zeros" c_CasADi__MX__zeros+ :: Ptr CRSSparsity' -> IO (Ptr MX')+casADi__MX__zeros+ :: CRSSparsity -> IO MX+casADi__MX__zeros x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__MX__zeros x0' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++-- classy wrapper+{-|+>Dense matrix of all zeros.+-}+mx_zeros :: CRSSparsity -> IO MX+mx_zeros = casADi__MX__zeros+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__zeros_TIC" c_CasADi__MX__zeros_TIC+ :: CInt -> CInt -> IO (Ptr MX')+casADi__MX__zeros'+ :: Int -> Int -> IO MX+casADi__MX__zeros' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__MX__zeros_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++-- classy wrapper+mx_zeros' :: Int -> Int -> IO MX+mx_zeros' = casADi__MX__zeros'+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__zeros_TIC_TIC" c_CasADi__MX__zeros_TIC_TIC+ :: CInt -> IO (Ptr MX')+casADi__MX__zeros''+ :: Int -> IO MX+casADi__MX__zeros'' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__MX__zeros_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++-- classy wrapper+mx_zeros'' :: Int -> IO MX+mx_zeros'' = casADi__MX__zeros''+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__ones" c_CasADi__MX__ones+ :: Ptr CRSSparsity' -> IO (Ptr MX')+casADi__MX__ones+ :: CRSSparsity -> IO MX+casADi__MX__ones x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__MX__ones x0' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++-- classy wrapper+{-|+>Matrix of all ones.+-}+mx_ones :: CRSSparsity -> IO MX+mx_ones = casADi__MX__ones+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__ones_TIC" c_CasADi__MX__ones_TIC+ :: CInt -> CInt -> IO (Ptr MX')+casADi__MX__ones'+ :: Int -> Int -> IO MX+casADi__MX__ones' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__MX__ones_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++-- classy wrapper+mx_ones' :: Int -> Int -> IO MX+mx_ones' = casADi__MX__ones'+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__ones_TIC_TIC" c_CasADi__MX__ones_TIC_TIC+ :: CInt -> IO (Ptr MX')+casADi__MX__ones''+ :: Int -> IO MX+casADi__MX__ones'' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__MX__ones_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++-- classy wrapper+mx_ones'' :: Int -> IO MX+mx_ones'' = casADi__MX__ones''+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__inf" c_CasADi__MX__inf+ :: Ptr CRSSparsity' -> IO (Ptr MX')+casADi__MX__inf+ :: CRSSparsity -> IO MX+casADi__MX__inf x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__MX__inf x0' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++-- classy wrapper+{-|+>create a matrix with all inf+-}+mx_inf :: CRSSparsity -> IO MX+mx_inf = casADi__MX__inf+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__inf_TIC" c_CasADi__MX__inf_TIC+ :: CInt -> CInt -> IO (Ptr MX')+casADi__MX__inf'+ :: Int -> Int -> IO MX+casADi__MX__inf' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__MX__inf_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++-- classy wrapper+mx_inf' :: Int -> Int -> IO MX+mx_inf' = casADi__MX__inf'+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__inf_TIC_TIC" c_CasADi__MX__inf_TIC_TIC+ :: CInt -> IO (Ptr MX')+casADi__MX__inf''+ :: Int -> IO MX+casADi__MX__inf'' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__MX__inf_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++-- classy wrapper+mx_inf'' :: Int -> IO MX+mx_inf'' = casADi__MX__inf''+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__inf_TIC_TIC_TIC" c_CasADi__MX__inf_TIC_TIC_TIC+ :: IO (Ptr MX')+casADi__MX__inf'''+ :: IO MX+casADi__MX__inf''' =+ c_CasADi__MX__inf_TIC_TIC_TIC >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++-- classy wrapper+mx_inf''' :: IO MX+mx_inf''' = casADi__MX__inf'''+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__nan" c_CasADi__MX__nan+ :: Ptr CRSSparsity' -> IO (Ptr MX')+casADi__MX__nan+ :: CRSSparsity -> IO MX+casADi__MX__nan x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__MX__nan x0' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++-- classy wrapper+{-|+>create a matrix with all nan+-}+mx_nan :: CRSSparsity -> IO MX+mx_nan = casADi__MX__nan+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__nan_TIC" c_CasADi__MX__nan_TIC+ :: CInt -> CInt -> IO (Ptr MX')+casADi__MX__nan'+ :: Int -> Int -> IO MX+casADi__MX__nan' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__MX__nan_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++-- classy wrapper+mx_nan' :: Int -> Int -> IO MX+mx_nan' = casADi__MX__nan'+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__nan_TIC_TIC" c_CasADi__MX__nan_TIC_TIC+ :: CInt -> IO (Ptr MX')+casADi__MX__nan''+ :: Int -> IO MX+casADi__MX__nan'' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__MX__nan_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++-- classy wrapper+mx_nan'' :: Int -> IO MX+mx_nan'' = casADi__MX__nan''+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__nan_TIC_TIC_TIC" c_CasADi__MX__nan_TIC_TIC_TIC+ :: IO (Ptr MX')+casADi__MX__nan'''+ :: IO MX+casADi__MX__nan''' =+ c_CasADi__MX__nan_TIC_TIC_TIC >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++-- classy wrapper+mx_nan''' :: IO MX+mx_nan''' = casADi__MX__nan'''+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__repmat" c_CasADi__MX__repmat+ :: Ptr MX' -> CInt -> CInt -> IO (Ptr MX')+casADi__MX__repmat+ :: MX -> Int -> Int -> IO MX+casADi__MX__repmat x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__MX__repmat x0' x1' x2' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++-- classy wrapper+{-|+>create a matrix by repeating an existing matrix+-}+mx_repmat :: MX -> Int -> Int -> IO MX+mx_repmat = casADi__MX__repmat+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__repmat_TIC" c_CasADi__MX__repmat_TIC+ :: Ptr MX' -> CInt -> IO (Ptr MX')+casADi__MX__repmat'+ :: MX -> Int -> IO MX+casADi__MX__repmat' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__MX__repmat_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++-- classy wrapper+mx_repmat' :: MX -> Int -> IO MX+mx_repmat' = casADi__MX__repmat'+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__eye" c_CasADi__MX__eye+ :: CInt -> IO (Ptr MX')+casADi__MX__eye+ :: Int -> IO MX+casADi__MX__eye x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__MX__eye x0' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++-- classy wrapper+mx_eye :: Int -> IO MX+mx_eye = casADi__MX__eye+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__getNZ" c_CasADi__MX__getNZ+ :: Ptr MX' -> CInt -> IO (Ptr MX')+casADi__MX__getNZ+ :: MX -> Int -> IO MX+casADi__MX__getNZ x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__MX__getNZ x0' x1' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++-- classy wrapper+mx_getNZ :: MXClass a => a -> Int -> IO MX+mx_getNZ x = casADi__MX__getNZ (castMX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__getNZ_TIC" c_CasADi__MX__getNZ_TIC+ :: Ptr MX' -> Ptr (CppVec CInt) -> IO (Ptr MX')+casADi__MX__getNZ'+ :: MX -> Vector Int -> IO MX+casADi__MX__getNZ' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__MX__getNZ_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++-- classy wrapper+mx_getNZ' :: MXClass a => a -> Vector Int -> IO MX+mx_getNZ' x = casADi__MX__getNZ' (castMX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__append" c_CasADi__MX__append+ :: Ptr MX' -> Ptr MX' -> IO ()+casADi__MX__append+ :: MX -> MX -> IO ()+casADi__MX__append x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__MX__append x0' x1' >>= wrapReturn++-- classy wrapper+{-|+>Append a matrix to the end.+-}+mx_append :: MXClass a => a -> MX -> IO ()+mx_append x = casADi__MX__append (castMX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX____add__" c_CasADi__MX____add__+ :: Ptr MX' -> Ptr MX' -> IO (Ptr MX')+casADi__MX____add__+ :: MX -> MX -> IO MX+casADi__MX____add__ x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__MX____add__ x0' x1' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++-- classy wrapper+mx___add__ :: MXClass a => a -> MX -> IO MX+mx___add__ x = casADi__MX____add__ (castMX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX____sub__" c_CasADi__MX____sub__+ :: Ptr MX' -> Ptr MX' -> IO (Ptr MX')+casADi__MX____sub__+ :: MX -> MX -> IO MX+casADi__MX____sub__ x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__MX____sub__ x0' x1' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++-- classy wrapper+mx___sub__ :: MXClass a => a -> MX -> IO MX+mx___sub__ x = casADi__MX____sub__ (castMX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX____mul__" c_CasADi__MX____mul__+ :: Ptr MX' -> Ptr MX' -> IO (Ptr MX')+casADi__MX____mul__+ :: MX -> MX -> IO MX+casADi__MX____mul__ x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__MX____mul__ x0' x1' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++-- classy wrapper+mx___mul__ :: MXClass a => a -> MX -> IO MX+mx___mul__ x = casADi__MX____mul__ (castMX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX____div__" c_CasADi__MX____div__+ :: Ptr MX' -> Ptr MX' -> IO (Ptr MX')+casADi__MX____div__+ :: MX -> MX -> IO MX+casADi__MX____div__ x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__MX____div__ x0' x1' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++-- classy wrapper+mx___div__ :: MXClass a => a -> MX -> IO MX+mx___div__ x = casADi__MX____div__ (castMX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX____lt__" c_CasADi__MX____lt__+ :: Ptr MX' -> Ptr MX' -> IO (Ptr MX')+casADi__MX____lt__+ :: MX -> MX -> IO MX+casADi__MX____lt__ x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__MX____lt__ x0' x1' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++-- classy wrapper+mx___lt__ :: MXClass a => a -> MX -> IO MX+mx___lt__ x = casADi__MX____lt__ (castMX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX____le__" c_CasADi__MX____le__+ :: Ptr MX' -> Ptr MX' -> IO (Ptr MX')+casADi__MX____le__+ :: MX -> MX -> IO MX+casADi__MX____le__ x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__MX____le__ x0' x1' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++-- classy wrapper+mx___le__ :: MXClass a => a -> MX -> IO MX+mx___le__ x = casADi__MX____le__ (castMX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX____eq__" c_CasADi__MX____eq__+ :: Ptr MX' -> Ptr MX' -> IO (Ptr MX')+casADi__MX____eq__+ :: MX -> MX -> IO MX+casADi__MX____eq__ x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__MX____eq__ x0' x1' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++-- classy wrapper+mx___eq__ :: MXClass a => a -> MX -> IO MX+mx___eq__ x = casADi__MX____eq__ (castMX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX____ne__" c_CasADi__MX____ne__+ :: Ptr MX' -> Ptr MX' -> IO (Ptr MX')+casADi__MX____ne__+ :: MX -> MX -> IO MX+casADi__MX____ne__ x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__MX____ne__ x0' x1' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++-- classy wrapper+mx___ne__ :: MXClass a => a -> MX -> IO MX+mx___ne__ x = casADi__MX____ne__ (castMX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX____truediv__" c_CasADi__MX____truediv__+ :: Ptr MX' -> Ptr MX' -> IO (Ptr MX')+casADi__MX____truediv__+ :: MX -> MX -> IO MX+casADi__MX____truediv__ x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__MX____truediv__ x0' x1' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++-- classy wrapper+{-|+>Division (with future.division in effect)+-}+mx___truediv__ :: MXClass a => a -> MX -> IO MX+mx___truediv__ x = casADi__MX____truediv__ (castMX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX____pow__" c_CasADi__MX____pow__+ :: Ptr MX' -> Ptr MX' -> IO (Ptr MX')+casADi__MX____pow__+ :: MX -> MX -> IO MX+casADi__MX____pow__ x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__MX____pow__ x0' x1' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++-- classy wrapper+mx___pow__ :: MXClass a => a -> MX -> IO MX+mx___pow__ x = casADi__MX____pow__ (castMX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX____constpow__" c_CasADi__MX____constpow__+ :: Ptr MX' -> Ptr MX' -> IO (Ptr MX')+casADi__MX____constpow__+ :: MX -> MX -> IO MX+casADi__MX____constpow__ x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__MX____constpow__ x0' x1' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++-- classy wrapper+mx___constpow__ :: MXClass a => a -> MX -> IO MX+mx___constpow__ x = casADi__MX____constpow__ (castMX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX____mrdivide__" c_CasADi__MX____mrdivide__+ :: Ptr MX' -> Ptr MX' -> IO (Ptr MX')+casADi__MX____mrdivide__+ :: MX -> MX -> IO MX+casADi__MX____mrdivide__ x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__MX____mrdivide__ x0' x1' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++-- classy wrapper+mx___mrdivide__ :: MXClass a => a -> MX -> IO MX+mx___mrdivide__ x = casADi__MX____mrdivide__ (castMX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX____mpower__" c_CasADi__MX____mpower__+ :: Ptr MX' -> Ptr MX' -> IO (Ptr MX')+casADi__MX____mpower__+ :: MX -> MX -> IO MX+casADi__MX____mpower__ x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__MX____mpower__ x0' x1' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++-- classy wrapper+mx___mpower__ :: MXClass a => a -> MX -> IO MX+mx___mpower__ x = casADi__MX____mpower__ (castMX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__mul" c_CasADi__MX__mul+ :: Ptr MX' -> Ptr MX' -> Ptr CRSSparsity' -> IO (Ptr MX')+casADi__MX__mul+ :: MX -> MX -> CRSSparsity -> IO MX+casADi__MX__mul x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__MX__mul x0' x1' x2' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++-- classy wrapper+mx_mul :: MXClass a => a -> MX -> CRSSparsity -> IO MX+mx_mul x = casADi__MX__mul (castMX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__mul_TIC" c_CasADi__MX__mul_TIC+ :: Ptr MX' -> Ptr MX' -> IO (Ptr MX')+casADi__MX__mul'+ :: MX -> MX -> IO MX+casADi__MX__mul' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__MX__mul_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++-- classy wrapper+mx_mul' :: MXClass a => a -> MX -> IO MX+mx_mul' x = casADi__MX__mul' (castMX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__mul_full" c_CasADi__MX__mul_full+ :: Ptr MX' -> Ptr MX' -> Ptr CRSSparsity' -> IO (Ptr MX')+casADi__MX__mul_full+ :: MX -> MX -> CRSSparsity -> IO MX+casADi__MX__mul_full x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__MX__mul_full x0' x1' x2' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++-- classy wrapper+mx_mul_full :: MXClass a => a -> MX -> CRSSparsity -> IO MX+mx_mul_full x = casADi__MX__mul_full (castMX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__mul_full_TIC" c_CasADi__MX__mul_full_TIC+ :: Ptr MX' -> Ptr MX' -> IO (Ptr MX')+casADi__MX__mul_full'+ :: MX -> MX -> IO MX+casADi__MX__mul_full' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__MX__mul_full_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++-- classy wrapper+mx_mul_full' :: MXClass a => a -> MX -> IO MX+mx_mul_full' x = casADi__MX__mul_full' (castMX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__inner_prod" c_CasADi__MX__inner_prod+ :: Ptr MX' -> Ptr MX' -> IO (Ptr MX')+casADi__MX__inner_prod+ :: MX -> MX -> IO MX+casADi__MX__inner_prod x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__MX__inner_prod x0' x1' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++-- classy wrapper+mx_inner_prod :: MXClass a => a -> MX -> IO MX+mx_inner_prod x = casADi__MX__inner_prod (castMX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__outer_prod" c_CasADi__MX__outer_prod+ :: Ptr MX' -> Ptr MX' -> IO (Ptr MX')+casADi__MX__outer_prod+ :: MX -> MX -> IO MX+casADi__MX__outer_prod x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__MX__outer_prod x0' x1' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++-- classy wrapper+mx_outer_prod :: MXClass a => a -> MX -> IO MX+mx_outer_prod x = casADi__MX__outer_prod (castMX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__constpow" c_CasADi__MX__constpow+ :: Ptr MX' -> Ptr MX' -> IO (Ptr MX')+casADi__MX__constpow+ :: MX -> MX -> IO MX+casADi__MX__constpow x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__MX__constpow x0' x1' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++-- classy wrapper+mx_constpow :: MXClass a => a -> MX -> IO MX+mx_constpow x = casADi__MX__constpow (castMX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__fmin" c_CasADi__MX__fmin+ :: Ptr MX' -> Ptr MX' -> IO (Ptr MX')+casADi__MX__fmin+ :: MX -> MX -> IO MX+casADi__MX__fmin x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__MX__fmin x0' x1' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++-- classy wrapper+mx_fmin :: MXClass a => a -> MX -> IO MX+mx_fmin x = casADi__MX__fmin (castMX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__fmax" c_CasADi__MX__fmax+ :: Ptr MX' -> Ptr MX' -> IO (Ptr MX')+casADi__MX__fmax+ :: MX -> MX -> IO MX+casADi__MX__fmax x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__MX__fmax x0' x1' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++-- classy wrapper+mx_fmax :: MXClass a => a -> MX -> IO MX+mx_fmax x = casADi__MX__fmax (castMX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__printme" c_CasADi__MX__printme+ :: Ptr MX' -> Ptr MX' -> IO (Ptr MX')+casADi__MX__printme+ :: MX -> MX -> IO MX+casADi__MX__printme x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__MX__printme x0' x1' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++-- classy wrapper+mx_printme :: MXClass a => a -> MX -> IO MX+mx_printme x = casADi__MX__printme (castMX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__arctan2" c_CasADi__MX__arctan2+ :: Ptr MX' -> Ptr MX' -> IO (Ptr MX')+casADi__MX__arctan2+ :: MX -> MX -> IO MX+casADi__MX__arctan2 x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__MX__arctan2 x0' x1' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++-- classy wrapper+mx_arctan2 :: MXClass a => a -> MX -> IO MX+mx_arctan2 x = casADi__MX__arctan2 (castMX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__logic_and" c_CasADi__MX__logic_and+ :: Ptr MX' -> Ptr MX' -> IO (Ptr MX')+casADi__MX__logic_and+ :: MX -> MX -> IO MX+casADi__MX__logic_and x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__MX__logic_and x0' x1' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++-- classy wrapper+mx_logic_and :: MXClass a => a -> MX -> IO MX+mx_logic_and x = casADi__MX__logic_and (castMX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__logic_or" c_CasADi__MX__logic_or+ :: Ptr MX' -> Ptr MX' -> IO (Ptr MX')+casADi__MX__logic_or+ :: MX -> MX -> IO MX+casADi__MX__logic_or x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__MX__logic_or x0' x1' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++-- classy wrapper+mx_logic_or :: MXClass a => a -> MX -> IO MX+mx_logic_or x = casADi__MX__logic_or (castMX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__if_else_zero" c_CasADi__MX__if_else_zero+ :: Ptr MX' -> Ptr MX' -> IO (Ptr MX')+casADi__MX__if_else_zero+ :: MX -> MX -> IO MX+casADi__MX__if_else_zero x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__MX__if_else_zero x0' x1' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++-- classy wrapper+mx_if_else_zero :: MXClass a => a -> MX -> IO MX+mx_if_else_zero x = casADi__MX__if_else_zero (castMX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__exp" c_CasADi__MX__exp+ :: Ptr MX' -> IO (Ptr MX')+casADi__MX__exp+ :: MX -> IO MX+casADi__MX__exp x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__MX__exp x0' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++-- classy wrapper+mx_exp :: MXClass a => a -> IO MX+mx_exp x = casADi__MX__exp (castMX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__log" c_CasADi__MX__log+ :: Ptr MX' -> IO (Ptr MX')+casADi__MX__log+ :: MX -> IO MX+casADi__MX__log x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__MX__log x0' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++-- classy wrapper+mx_log :: MXClass a => a -> IO MX+mx_log x = casADi__MX__log (castMX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__log10" c_CasADi__MX__log10+ :: Ptr MX' -> IO (Ptr MX')+casADi__MX__log10+ :: MX -> IO MX+casADi__MX__log10 x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__MX__log10 x0' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++-- classy wrapper+mx_log10 :: MXClass a => a -> IO MX+mx_log10 x = casADi__MX__log10 (castMX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__sqrt" c_CasADi__MX__sqrt+ :: Ptr MX' -> IO (Ptr MX')+casADi__MX__sqrt+ :: MX -> IO MX+casADi__MX__sqrt x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__MX__sqrt x0' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++-- classy wrapper+mx_sqrt :: MXClass a => a -> IO MX+mx_sqrt x = casADi__MX__sqrt (castMX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__sin" c_CasADi__MX__sin+ :: Ptr MX' -> IO (Ptr MX')+casADi__MX__sin+ :: MX -> IO MX+casADi__MX__sin x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__MX__sin x0' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++-- classy wrapper+mx_sin :: MXClass a => a -> IO MX+mx_sin x = casADi__MX__sin (castMX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__cos" c_CasADi__MX__cos+ :: Ptr MX' -> IO (Ptr MX')+casADi__MX__cos+ :: MX -> IO MX+casADi__MX__cos x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__MX__cos x0' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++-- classy wrapper+mx_cos :: MXClass a => a -> IO MX+mx_cos x = casADi__MX__cos (castMX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__tan" c_CasADi__MX__tan+ :: Ptr MX' -> IO (Ptr MX')+casADi__MX__tan+ :: MX -> IO MX+casADi__MX__tan x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__MX__tan x0' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++-- classy wrapper+mx_tan :: MXClass a => a -> IO MX+mx_tan x = casADi__MX__tan (castMX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__arcsin" c_CasADi__MX__arcsin+ :: Ptr MX' -> IO (Ptr MX')+casADi__MX__arcsin+ :: MX -> IO MX+casADi__MX__arcsin x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__MX__arcsin x0' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++-- classy wrapper+mx_arcsin :: MXClass a => a -> IO MX+mx_arcsin x = casADi__MX__arcsin (castMX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__arccos" c_CasADi__MX__arccos+ :: Ptr MX' -> IO (Ptr MX')+casADi__MX__arccos+ :: MX -> IO MX+casADi__MX__arccos x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__MX__arccos x0' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++-- classy wrapper+mx_arccos :: MXClass a => a -> IO MX+mx_arccos x = casADi__MX__arccos (castMX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__arctan" c_CasADi__MX__arctan+ :: Ptr MX' -> IO (Ptr MX')+casADi__MX__arctan+ :: MX -> IO MX+casADi__MX__arctan x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__MX__arctan x0' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++-- classy wrapper+mx_arctan :: MXClass a => a -> IO MX+mx_arctan x = casADi__MX__arctan (castMX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__floor" c_CasADi__MX__floor+ :: Ptr MX' -> IO (Ptr MX')+casADi__MX__floor+ :: MX -> IO MX+casADi__MX__floor x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__MX__floor x0' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++-- classy wrapper+mx_floor :: MXClass a => a -> IO MX+mx_floor x = casADi__MX__floor (castMX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__ceil" c_CasADi__MX__ceil+ :: Ptr MX' -> IO (Ptr MX')+casADi__MX__ceil+ :: MX -> IO MX+casADi__MX__ceil x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__MX__ceil x0' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++-- classy wrapper+mx_ceil :: MXClass a => a -> IO MX+mx_ceil x = casADi__MX__ceil (castMX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__fabs" c_CasADi__MX__fabs+ :: Ptr MX' -> IO (Ptr MX')+casADi__MX__fabs+ :: MX -> IO MX+casADi__MX__fabs x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__MX__fabs x0' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++-- classy wrapper+mx_fabs :: MXClass a => a -> IO MX+mx_fabs x = casADi__MX__fabs (castMX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__sign" c_CasADi__MX__sign+ :: Ptr MX' -> IO (Ptr MX')+casADi__MX__sign+ :: MX -> IO MX+casADi__MX__sign x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__MX__sign x0' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++-- classy wrapper+mx_sign :: MXClass a => a -> IO MX+mx_sign x = casADi__MX__sign (castMX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__erfinv" c_CasADi__MX__erfinv+ :: Ptr MX' -> IO (Ptr MX')+casADi__MX__erfinv+ :: MX -> IO MX+casADi__MX__erfinv x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__MX__erfinv x0' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++-- classy wrapper+mx_erfinv :: MXClass a => a -> IO MX+mx_erfinv x = casADi__MX__erfinv (castMX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__erf" c_CasADi__MX__erf+ :: Ptr MX' -> IO (Ptr MX')+casADi__MX__erf+ :: MX -> IO MX+casADi__MX__erf x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__MX__erf x0' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++-- classy wrapper+mx_erf :: MXClass a => a -> IO MX+mx_erf x = casADi__MX__erf (castMX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__sinh" c_CasADi__MX__sinh+ :: Ptr MX' -> IO (Ptr MX')+casADi__MX__sinh+ :: MX -> IO MX+casADi__MX__sinh x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__MX__sinh x0' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++-- classy wrapper+mx_sinh :: MXClass a => a -> IO MX+mx_sinh x = casADi__MX__sinh (castMX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__cosh" c_CasADi__MX__cosh+ :: Ptr MX' -> IO (Ptr MX')+casADi__MX__cosh+ :: MX -> IO MX+casADi__MX__cosh x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__MX__cosh x0' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++-- classy wrapper+mx_cosh :: MXClass a => a -> IO MX+mx_cosh x = casADi__MX__cosh (castMX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__tanh" c_CasADi__MX__tanh+ :: Ptr MX' -> IO (Ptr MX')+casADi__MX__tanh+ :: MX -> IO MX+casADi__MX__tanh x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__MX__tanh x0' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++-- classy wrapper+mx_tanh :: MXClass a => a -> IO MX+mx_tanh x = casADi__MX__tanh (castMX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__arcsinh" c_CasADi__MX__arcsinh+ :: Ptr MX' -> IO (Ptr MX')+casADi__MX__arcsinh+ :: MX -> IO MX+casADi__MX__arcsinh x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__MX__arcsinh x0' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++-- classy wrapper+mx_arcsinh :: MXClass a => a -> IO MX+mx_arcsinh x = casADi__MX__arcsinh (castMX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__arccosh" c_CasADi__MX__arccosh+ :: Ptr MX' -> IO (Ptr MX')+casADi__MX__arccosh+ :: MX -> IO MX+casADi__MX__arccosh x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__MX__arccosh x0' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++-- classy wrapper+mx_arccosh :: MXClass a => a -> IO MX+mx_arccosh x = casADi__MX__arccosh (castMX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__arctanh" c_CasADi__MX__arctanh+ :: Ptr MX' -> IO (Ptr MX')+casADi__MX__arctanh+ :: MX -> IO MX+casADi__MX__arctanh x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__MX__arctanh x0' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++-- classy wrapper+mx_arctanh :: MXClass a => a -> IO MX+mx_arctanh x = casADi__MX__arctanh (castMX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__logic_not" c_CasADi__MX__logic_not+ :: Ptr MX' -> IO (Ptr MX')+casADi__MX__logic_not+ :: MX -> IO MX+casADi__MX__logic_not x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__MX__logic_not x0' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++-- classy wrapper+mx_logic_not :: MXClass a => a -> IO MX+mx_logic_not x = casADi__MX__logic_not (castMX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__attachAssert" c_CasADi__MX__attachAssert+ :: Ptr MX' -> Ptr MX' -> Ptr StdString' -> IO (Ptr MX')+casADi__MX__attachAssert+ :: MX -> MX -> String -> IO MX+casADi__MX__attachAssert x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__MX__attachAssert x0' x1' x2' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++-- classy wrapper+{-|+>returns itself, but with an assertion attached+>+>If y does not evaluate to 1, a runtime error is raised+-}+mx_attachAssert :: MXClass a => a -> MX -> String -> IO MX+mx_attachAssert x = casADi__MX__attachAssert (castMX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__attachAssert_TIC" c_CasADi__MX__attachAssert_TIC+ :: Ptr MX' -> Ptr MX' -> IO (Ptr MX')+casADi__MX__attachAssert'+ :: MX -> MX -> IO MX+casADi__MX__attachAssert' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__MX__attachAssert_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++-- classy wrapper+mx_attachAssert' :: MXClass a => a -> MX -> IO MX+mx_attachAssert' x = casADi__MX__attachAssert' (castMX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__setSparse" c_CasADi__MX__setSparse+ :: Ptr MX' -> Ptr CRSSparsity' -> Ptr CppBool' -> IO (Ptr MX')+casADi__MX__setSparse+ :: MX -> CRSSparsity -> Bool -> IO MX+casADi__MX__setSparse x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__MX__setSparse x0' x1' x2' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++-- classy wrapper+{-|+>Set sparse.+-}+mx_setSparse :: MXClass a => a -> CRSSparsity -> Bool -> IO MX+mx_setSparse x = casADi__MX__setSparse (castMX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__setSparse_TIC" c_CasADi__MX__setSparse_TIC+ :: Ptr MX' -> Ptr CRSSparsity' -> IO (Ptr MX')+casADi__MX__setSparse'+ :: MX -> CRSSparsity -> IO MX+casADi__MX__setSparse' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__MX__setSparse_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++-- classy wrapper+mx_setSparse' :: MXClass a => a -> CRSSparsity -> IO MX+mx_setSparse' x = casADi__MX__setSparse' (castMX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__makeDense" c_CasADi__MX__makeDense+ :: Ptr MX' -> Ptr MX' -> IO (Ptr MX')+casADi__MX__makeDense+ :: MX -> MX -> IO MX+casADi__MX__makeDense x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__MX__makeDense x0' x1' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++-- classy wrapper+{-|+>Make dense.+-}+mx_makeDense :: MXClass a => a -> MX -> IO MX+mx_makeDense x = casADi__MX__makeDense (castMX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__makeDense_TIC" c_CasADi__MX__makeDense_TIC+ :: Ptr MX' -> IO (Ptr MX')+casADi__MX__makeDense'+ :: MX -> IO MX+casADi__MX__makeDense' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__MX__makeDense_TIC x0' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++-- classy wrapper+mx_makeDense' :: MXClass a => a -> IO MX+mx_makeDense' x = casADi__MX__makeDense' (castMX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__lift" c_CasADi__MX__lift+ :: Ptr MX' -> Ptr MX' -> IO ()+casADi__MX__lift+ :: MX -> MX -> IO ()+casADi__MX__lift x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__MX__lift x0' x1' >>= wrapReturn++-- classy wrapper+{-|+>Lift an expression.+-}+mx_lift :: MXClass a => a -> MX -> IO ()+mx_lift x = casADi__MX__lift (castMX x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__setMaxNumCallsInPrint" c_CasADi__MX__setMaxNumCallsInPrint+ :: CLong -> IO ()+casADi__MX__setMaxNumCallsInPrint+ :: Int -> IO ()+casADi__MX__setMaxNumCallsInPrint x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__MX__setMaxNumCallsInPrint x0' >>= wrapReturn++-- classy wrapper+mx_setMaxNumCallsInPrint :: Int -> IO ()+mx_setMaxNumCallsInPrint = casADi__MX__setMaxNumCallsInPrint+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__setMaxNumCallsInPrint_TIC" c_CasADi__MX__setMaxNumCallsInPrint_TIC+ :: IO ()+casADi__MX__setMaxNumCallsInPrint'+ :: IO ()+casADi__MX__setMaxNumCallsInPrint' =+ c_CasADi__MX__setMaxNumCallsInPrint_TIC >>= wrapReturn++-- classy wrapper+mx_setMaxNumCallsInPrint' :: IO ()+mx_setMaxNumCallsInPrint' = casADi__MX__setMaxNumCallsInPrint'+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__getMaxNumCallsInPrint" c_CasADi__MX__getMaxNumCallsInPrint+ :: IO CLong+casADi__MX__getMaxNumCallsInPrint+ :: IO Int+casADi__MX__getMaxNumCallsInPrint =+ c_CasADi__MX__getMaxNumCallsInPrint >>= wrapReturn++-- classy wrapper+mx_getMaxNumCallsInPrint :: IO Int+mx_getMaxNumCallsInPrint = casADi__MX__getMaxNumCallsInPrint+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__setEqualityCheckingDepth" c_CasADi__MX__setEqualityCheckingDepth+ :: CInt -> IO ()+casADi__MX__setEqualityCheckingDepth+ :: Int -> IO ()+casADi__MX__setEqualityCheckingDepth x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__MX__setEqualityCheckingDepth x0' >>= wrapReturn++-- classy wrapper+mx_setEqualityCheckingDepth :: Int -> IO ()+mx_setEqualityCheckingDepth = casADi__MX__setEqualityCheckingDepth+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__setEqualityCheckingDepth_TIC" c_CasADi__MX__setEqualityCheckingDepth_TIC+ :: IO ()+casADi__MX__setEqualityCheckingDepth'+ :: IO ()+casADi__MX__setEqualityCheckingDepth' =+ c_CasADi__MX__setEqualityCheckingDepth_TIC >>= wrapReturn++-- classy wrapper+mx_setEqualityCheckingDepth' :: IO ()+mx_setEqualityCheckingDepth' = casADi__MX__setEqualityCheckingDepth'+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__getEqualityCheckingDepth" c_CasADi__MX__getEqualityCheckingDepth+ :: IO CInt+casADi__MX__getEqualityCheckingDepth+ :: IO Int+casADi__MX__getEqualityCheckingDepth =+ c_CasADi__MX__getEqualityCheckingDepth >>= wrapReturn++-- classy wrapper+mx_getEqualityCheckingDepth :: IO Int+mx_getEqualityCheckingDepth = casADi__MX__getEqualityCheckingDepth+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__MX" c_CasADi__MX__MX+ :: IO (Ptr MX')+casADi__MX__MX+ :: IO MX+casADi__MX__MX =+ c_CasADi__MX__MX >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++-- classy wrapper+{-|+>> CasADi::MX::MX()+>------------------------------------------------------------------------+>+>Default constructor.+>+>> CasADi::MX::MX(const std::string &name, int n=1, int m=1)+>+>> CasADi::MX::MX(const std::string &name, const std::pair< int, int > &nm)+>+>> CasADi::MX::MX(const std::string &name, const CRSSparsity &sp)+>------------------------------------------------------------------------+>+>Construct a symbolic matrix (matrix variable)+>+>> CasADi::MX::MX(const CRSSparsity &sp, const MX &val=0)+>------------------------------------------------------------------------+>+>Construct MX with a given sparsity.+>+>> CasADi::MX::MX(double x)+>------------------------------------------------------------------------+>+>Create scalar constant (also implicit type conversion)+>+>> CasADi::MX::MX(const MX &x)+>------------------------------------------------------------------------+>+>Copy constructor.+>+>> CasADi::MX::MX(const std::vector< double > &x)+>------------------------------------------------------------------------+>+>Create vector constant (also implicit type conversion)+>+>> CasADi::MX::MX(const Matrix< double > &x)+>------------------------------------------------------------------------+>+>Create sparse matrix constant (also implicit type conversion)+>+>> CasADi::MX::MX(int nrow, int ncol)+>------------------------------------------------------------------------+>+>Matrix with all zeros.+>+>> CasADi::MX::MX(int nrow, int ncol, const MX &val)+>------------------------------------------------------------------------+>+>Dense matrix filled with value val.+-}+mx :: IO MX+mx = casADi__MX__MX+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__MX_TIC" c_CasADi__MX__MX_TIC+ :: Ptr StdString' -> CInt -> CInt -> IO (Ptr MX')+casADi__MX__MX'+ :: String -> Int -> Int -> IO MX+casADi__MX__MX' x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__MX__MX_TIC x0' x1' x2' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++-- classy wrapper+mx' :: String -> Int -> Int -> IO MX+mx' = casADi__MX__MX'+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__MX_TIC_TIC" c_CasADi__MX__MX_TIC_TIC+ :: Ptr StdString' -> CInt -> IO (Ptr MX')+casADi__MX__MX''+ :: String -> Int -> IO MX+casADi__MX__MX'' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__MX__MX_TIC_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++-- classy wrapper+mx'' :: String -> Int -> IO MX+mx'' = casADi__MX__MX''+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__MX_TIC_TIC_TIC" c_CasADi__MX__MX_TIC_TIC_TIC+ :: Ptr StdString' -> IO (Ptr MX')+casADi__MX__MX'''+ :: String -> IO MX+casADi__MX__MX''' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__MX__MX_TIC_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++-- classy wrapper+mx''' :: String -> IO MX+mx''' = casADi__MX__MX'''+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__MX_TIC_TIC_TIC_TIC" c_CasADi__MX__MX_TIC_TIC_TIC_TIC+ :: Ptr StdString' -> Ptr CRSSparsity' -> IO (Ptr MX')+casADi__MX__MX''''+ :: String -> CRSSparsity -> IO MX+casADi__MX__MX'''' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__MX__MX_TIC_TIC_TIC_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++-- classy wrapper+mx'''' :: String -> CRSSparsity -> IO MX+mx'''' = casADi__MX__MX''''+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC" c_CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC+ :: Ptr CRSSparsity' -> Ptr MX' -> IO (Ptr MX')+casADi__MX__MX'''''+ :: CRSSparsity -> MX -> IO MX+casADi__MX__MX''''' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++-- classy wrapper+mx''''' :: CRSSparsity -> MX -> IO MX+mx''''' = casADi__MX__MX'''''+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC_TIC+ :: Ptr CRSSparsity' -> IO (Ptr MX')+casADi__MX__MX''''''+ :: CRSSparsity -> IO MX+casADi__MX__MX'''''' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++-- classy wrapper+mx'''''' :: CRSSparsity -> IO MX+mx'''''' = casADi__MX__MX''''''+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC_TIC_TIC+ :: CDouble -> IO (Ptr MX')+casADi__MX__MX'''''''+ :: Double -> IO MX+casADi__MX__MX''''''' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++-- classy wrapper+mx''''''' :: Double -> IO MX+mx''''''' = casADi__MX__MX'''''''+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC+ :: Ptr MX' -> IO (Ptr MX')+casADi__MX__MX''''''''+ :: MX -> IO MX+casADi__MX__MX'''''''' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++-- classy wrapper+mx'''''''' :: MX -> IO MX+mx'''''''' = casADi__MX__MX''''''''+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC+ :: Ptr (CppVec CDouble) -> IO (Ptr MX')+casADi__MX__MX'''''''''+ :: Vector Double -> IO MX+casADi__MX__MX''''''''' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++-- classy wrapper+mx''''''''' :: Vector Double -> IO MX+mx''''''''' = casADi__MX__MX'''''''''+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC+ :: Ptr DMatrix' -> IO (Ptr MX')+casADi__MX__MX''''''''''+ :: DMatrix -> IO MX+casADi__MX__MX'''''''''' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++-- classy wrapper+mx'''''''''' :: DMatrix -> IO MX+mx'''''''''' = casADi__MX__MX''''''''''+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC+ :: CInt -> CInt -> IO (Ptr MX')+casADi__MX__MX'''''''''''+ :: Int -> Int -> IO MX+casADi__MX__MX''''''''''' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++-- classy wrapper+mx''''''''''' :: Int -> Int -> IO MX+mx''''''''''' = casADi__MX__MX'''''''''''+++-- direct wrapper+foreign import ccall unsafe "CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC+ :: CInt -> CInt -> Ptr MX' -> IO (Ptr MX')+casADi__MX__MX''''''''''''+ :: Int -> Int -> MX -> IO MX+casADi__MX__MX'''''''''''' x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++-- classy wrapper+mx'''''''''''' :: Int -> Int -> MX -> IO MX+mx'''''''''''' = casADi__MX__MX''''''''''''+
+ Casadi/Wrappers/Classes/MXFunction.hs view
@@ -0,0 +1,253 @@+{-# OPTIONS_GHC -Wall #-}+{-# OPTIONS_GHC -fno-warn-unused-imports #-}+{-# OPTIONS_GHC -fno-warn-orphans #-}+{-# Language ForeignFunctionInterface #-}+{-# Language FlexibleInstances #-}+{-# Language MultiParamTypeClasses #-}++module Casadi.Wrappers.Classes.MXFunction+ (+ MXFunction,+ MXFunctionClass(..),+ mxFunction,+ mxFunction',+ mxFunction_checkNode,+ mxFunction_countNodes,+ mxFunction_generateLiftingFunctions,+ mxFunction_getAlgorithmSize,+ mxFunction_getFree,+ mxFunction_getWorkSize,+ mxFunction_grad,+ mxFunction_jac,+ ) where+++import Prelude hiding ( Functor )++import Data.Vector ( Vector )+import Foreign.C.Types+import Foreign.Ptr ( Ptr )+import Foreign.ForeignPtr ( newForeignPtr )+import System.IO.Unsafe ( unsafePerformIO ) -- for show instances++import Casadi.Wrappers.Classes.PrintableObject+import Casadi.Wrappers.ForeignToolsInstances ( )+import Casadi.Wrappers.Deleters+import Casadi.Wrappers.Data+import Casadi.Wrappers.Enums+import Casadi.MarshalTypes ( CppVec, CppVecVec, CppVecVecVec,+ StdString', CppBool' ) -- StdOstream'+import Casadi.Marshal ( CornerCase(..), Marshal(..) )+import Casadi.WrapReturn ( WrapReturn(..) )++instance Show MXFunction where+ show = unsafePerformIO . printableObject_getDescription+-- direct wrapper+foreign import ccall unsafe "CasADi__MXFunction__getAlgorithmSize" c_CasADi__MXFunction__getAlgorithmSize+ :: Ptr MXFunction' -> IO CInt+casADi__MXFunction__getAlgorithmSize+ :: MXFunction -> IO Int+casADi__MXFunction__getAlgorithmSize x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__MXFunction__getAlgorithmSize x0' >>= wrapReturn++-- classy wrapper+{-|+>Get the number of atomic operations.+-}+mxFunction_getAlgorithmSize :: MXFunctionClass a => a -> IO Int+mxFunction_getAlgorithmSize x = casADi__MXFunction__getAlgorithmSize (castMXFunction x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__MXFunction__getWorkSize" c_CasADi__MXFunction__getWorkSize+ :: Ptr MXFunction' -> IO CInt+casADi__MXFunction__getWorkSize+ :: MXFunction -> IO Int+casADi__MXFunction__getWorkSize x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__MXFunction__getWorkSize x0' >>= wrapReturn++-- classy wrapper+{-|+>Get the length of the work vector.+-}+mxFunction_getWorkSize :: MXFunctionClass a => a -> IO Int+mxFunction_getWorkSize x = casADi__MXFunction__getWorkSize (castMXFunction x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__MXFunction__countNodes" c_CasADi__MXFunction__countNodes+ :: Ptr MXFunction' -> IO CInt+casADi__MXFunction__countNodes+ :: MXFunction -> IO Int+casADi__MXFunction__countNodes x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__MXFunction__countNodes x0' >>= wrapReturn++-- classy wrapper+{-|+>Number of nodes in the algorithm.+-}+mxFunction_countNodes :: MXFunctionClass a => a -> IO Int+mxFunction_countNodes x = casADi__MXFunction__countNodes (castMXFunction x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__MXFunction__checkNode" c_CasADi__MXFunction__checkNode+ :: Ptr MXFunction' -> IO (Ptr CppBool')+casADi__MXFunction__checkNode+ :: MXFunction -> IO Bool+casADi__MXFunction__checkNode x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__MXFunction__checkNode x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++-- classy wrapper+{-|+>Check if the node is pointing to the right type of object.+-}+mxFunction_checkNode :: MXFunctionClass a => a -> IO Bool+mxFunction_checkNode x = casADi__MXFunction__checkNode (castMXFunction x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__MXFunction__jac" c_CasADi__MXFunction__jac+ :: Ptr MXFunction' -> CInt -> CInt -> Ptr CppBool' -> Ptr CppBool' -> IO (Ptr MX')+casADi__MXFunction__jac+ :: MXFunction -> Int -> Int -> Bool -> Bool -> IO MX+casADi__MXFunction__jac x0 x1 x2 x3 x4 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ withMarshal x3 $ \x3' ->+ withMarshal x4 $ \x4' ->+ c_CasADi__MXFunction__jac x0' x1' x2' x3' x4' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++-- classy wrapper+{-|+>Jacobian via source code transformation.+-}+mxFunction_jac :: MXFunctionClass a => a -> Int -> Int -> Bool -> Bool -> IO MX+mxFunction_jac x = casADi__MXFunction__jac (castMXFunction x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__MXFunction__grad" c_CasADi__MXFunction__grad+ :: Ptr MXFunction' -> CInt -> CInt -> IO (Ptr MX')+casADi__MXFunction__grad+ :: MXFunction -> Int -> Int -> IO MX+casADi__MXFunction__grad x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__MXFunction__grad x0' x1' x2' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++-- classy wrapper+{-|+>Gradient via source code transformation.+-}+mxFunction_grad :: MXFunctionClass a => a -> Int -> Int -> IO MX+mxFunction_grad x = casADi__MXFunction__grad (castMXFunction x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__MXFunction__getFree" c_CasADi__MXFunction__getFree+ :: Ptr MXFunction' -> IO (Ptr (CppVec (Ptr MX')))+casADi__MXFunction__getFree+ :: MXFunction -> IO (Vector MX)+casADi__MXFunction__getFree x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__MXFunction__getFree x0' >>= (newForeignPtr c_delete_std__vector_CasADi__MX_) >>= wrapReturn++-- classy wrapper+{-|+>Get all the free variables of the function.+-}+mxFunction_getFree :: MXFunctionClass a => a -> IO (Vector MX)+mxFunction_getFree x = casADi__MXFunction__getFree (castMXFunction x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__MXFunction__generateLiftingFunctions" c_CasADi__MXFunction__generateLiftingFunctions+ :: Ptr MXFunction' -> Ptr MXFunction' -> Ptr MXFunction' -> IO ()+casADi__MXFunction__generateLiftingFunctions+ :: MXFunction -> MXFunction -> MXFunction -> IO ()+casADi__MXFunction__generateLiftingFunctions x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__MXFunction__generateLiftingFunctions x0' x1' x2' >>= wrapReturn++-- classy wrapper+{-|+>Extract the functions needed for the Lifted Newton method.+-}+mxFunction_generateLiftingFunctions :: MXFunctionClass a => a -> MXFunction -> MXFunction -> IO ()+mxFunction_generateLiftingFunctions x = casADi__MXFunction__generateLiftingFunctions (castMXFunction x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__MXFunction__MXFunction_TIC" c_CasADi__MXFunction__MXFunction_TIC+ :: Ptr FX' -> IO (Ptr MXFunction')+casADi__MXFunction__MXFunction'+ :: FX -> IO MXFunction+casADi__MXFunction__MXFunction' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__MXFunction__MXFunction_TIC x0' >>= (newForeignPtr c_delete_CasADi__MXFunction) >>= wrapReturn++-- classy wrapper+mxFunction' :: FX -> IO MXFunction+mxFunction' = casADi__MXFunction__MXFunction'+++-- direct wrapper+foreign import ccall unsafe "CasADi__MXFunction__MXFunction" c_CasADi__MXFunction__MXFunction+ :: Ptr (CppVec (Ptr MX')) -> Ptr (CppVec (Ptr MX')) -> IO (Ptr MXFunction')+casADi__MXFunction__MXFunction+ :: Vector MX -> Vector MX -> IO MXFunction+casADi__MXFunction__MXFunction x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__MXFunction__MXFunction x0' x1' >>= (newForeignPtr c_delete_CasADi__MXFunction) >>= wrapReturn++-- classy wrapper+{-|+>> CasADi::MXFunction::MXFunction()+>------------------------------------------------------------------------+>+>Default constructor.+>+>> CasADi::MXFunction::MXFunction(const FX &fx)+>------------------------------------------------------------------------+>+>Attempt to form an MXFunction out of an FX.+>+>> CasADi::MXFunction::MXFunction(const MX &input, const MX &output)+>------------------------------------------------------------------------+>+>Single input, single output.+>+>> CasADi::MXFunction::MXFunction(const MX &input, const std::vector< MX > &output)+>------------------------------------------------------------------------+>+>Single input, multiple output.+>+>> CasADi::MXFunction::MXFunction(const std::vector< MX > &input, const MX &output)+>------------------------------------------------------------------------+>+>Multiple input, single output.+>+>> CasADi::MXFunction::MXFunction(const std::vector< MX > &input, const std::vector< MX > &output)+>+>> CasADi::MXFunction::MXFunction(const std::vector< MX > &input, const IOSchemeVector< MX > &output)+>+>> CasADi::MXFunction::MXFunction(const IOSchemeVector< MX > &input, const std::vector< MX > &output)+>+>> CasADi::MXFunction::MXFunction(const IOSchemeVector< MX > &input, const IOSchemeVector< MX > &output)+>------------------------------------------------------------------------+>+>Multiple input, multiple output.+-}+mxFunction :: Vector MX -> Vector MX -> IO MXFunction+mxFunction = casADi__MXFunction__MXFunction+
+ Casadi/Wrappers/Classes/OptionsFunctionality.hs view
@@ -0,0 +1,403 @@+{-# OPTIONS_GHC -Wall #-}+{-# OPTIONS_GHC -fno-warn-unused-imports #-}+{-# OPTIONS_GHC -fno-warn-orphans #-}+{-# Language ForeignFunctionInterface #-}+{-# Language FlexibleInstances #-}+{-# Language MultiParamTypeClasses #-}++module Casadi.Wrappers.Classes.OptionsFunctionality+ (+ OptionsFunctionality,+ OptionsFunctionalityClass(..),+ optionsFunctionality,+ optionsFunctionality_checkNode,+ optionsFunctionality_copyOptions,+ optionsFunctionality_copyOptions',+ optionsFunctionality_getOption,+ optionsFunctionality_getOptionAllowed,+ optionsFunctionality_getOptionAllowedIndex,+ optionsFunctionality_getOptionDefault,+ optionsFunctionality_getOptionDescription,+ optionsFunctionality_getOptionEnumValue,+ optionsFunctionality_getOptionNames,+ optionsFunctionality_getOptionType,+ optionsFunctionality_getOptionTypeName,+ optionsFunctionality_hasOption,+ optionsFunctionality_hasSetOption,+ optionsFunctionality_printOptions',+ optionsFunctionality_setOption,+ optionsFunctionality_setOptionByAllowedIndex,+ optionsFunctionality_setOptionByEnumValue,+ ) where+++import Prelude hiding ( Functor )++import Data.Vector ( Vector )+import Foreign.C.Types+import Foreign.Ptr ( Ptr )+import Foreign.ForeignPtr ( newForeignPtr )+import System.IO.Unsafe ( unsafePerformIO ) -- for show instances++import Casadi.Wrappers.Classes.PrintableObject+import Casadi.Wrappers.ForeignToolsInstances ( )+import Casadi.Wrappers.Deleters+import Casadi.Wrappers.Data+import Casadi.Wrappers.Enums+import Casadi.MarshalTypes ( CppVec, CppVecVec, CppVecVecVec,+ StdString', CppBool' ) -- StdOstream'+import Casadi.Marshal ( CornerCase(..), Marshal(..) )+import Casadi.WrapReturn ( WrapReturn(..) )++instance Show OptionsFunctionality where+ show = unsafePerformIO . printableObject_getDescription+-- direct wrapper+foreign import ccall unsafe "CasADi__OptionsFunctionality__setOption" c_CasADi__OptionsFunctionality__setOption+ :: Ptr OptionsFunctionality' -> Ptr StdString' -> Ptr GenericType' -> IO ()+casADi__OptionsFunctionality__setOption+ :: OptionsFunctionality -> String -> GenericType -> IO ()+casADi__OptionsFunctionality__setOption x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__OptionsFunctionality__setOption x0' x1' x2' >>= wrapReturn++-- classy wrapper+{-|+>> void CasADi::OptionsFunctionality::setOption(const std::string &str, const GenericType &val)+>------------------------------------------------------------------------+>+>set an option. For a list of options, check the class documentation of this+>class.+>+>The setOptions are only considered before the init function. If properties+>changes, the init function should be called again.+>+>> void CasADi::OptionsFunctionality::setOption(const Dictionary &dict, bool skipUnknown=false)+>------------------------------------------------------------------------+>+>set a set of options. For a list of options, check the class documentation+>of this class.+>+>The setOptions are only considered before the init function. If properties+>changes, the init function should be called again.+-}+optionsFunctionality_setOption :: OptionsFunctionalityClass a => a -> String -> GenericType -> IO ()+optionsFunctionality_setOption x = casADi__OptionsFunctionality__setOption (castOptionsFunctionality x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__OptionsFunctionality__getOption" c_CasADi__OptionsFunctionality__getOption+ :: Ptr OptionsFunctionality' -> Ptr StdString' -> IO (Ptr GenericType')+casADi__OptionsFunctionality__getOption+ :: OptionsFunctionality -> String -> IO GenericType+casADi__OptionsFunctionality__getOption x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__OptionsFunctionality__getOption x0' x1' >>= (newForeignPtr c_delete_CasADi__GenericType) >>= wrapReturn++-- classy wrapper+{-|+>get an option value+-}+optionsFunctionality_getOption :: OptionsFunctionalityClass a => a -> String -> IO GenericType+optionsFunctionality_getOption x = casADi__OptionsFunctionality__getOption (castOptionsFunctionality x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__OptionsFunctionality__hasOption" c_CasADi__OptionsFunctionality__hasOption+ :: Ptr OptionsFunctionality' -> Ptr StdString' -> IO (Ptr CppBool')+casADi__OptionsFunctionality__hasOption+ :: OptionsFunctionality -> String -> IO Bool+casADi__OptionsFunctionality__hasOption x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__OptionsFunctionality__hasOption x0' x1' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++-- classy wrapper+{-|+>check if there is an option str+-}+optionsFunctionality_hasOption :: OptionsFunctionalityClass a => a -> String -> IO Bool+optionsFunctionality_hasOption x = casADi__OptionsFunctionality__hasOption (castOptionsFunctionality x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__OptionsFunctionality__hasSetOption" c_CasADi__OptionsFunctionality__hasSetOption+ :: Ptr OptionsFunctionality' -> Ptr StdString' -> IO (Ptr CppBool')+casADi__OptionsFunctionality__hasSetOption+ :: OptionsFunctionality -> String -> IO Bool+casADi__OptionsFunctionality__hasSetOption x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__OptionsFunctionality__hasSetOption x0' x1' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++-- classy wrapper+{-|+>check if the user has there is an option str+-}+optionsFunctionality_hasSetOption :: OptionsFunctionalityClass a => a -> String -> IO Bool+optionsFunctionality_hasSetOption x = casADi__OptionsFunctionality__hasSetOption (castOptionsFunctionality x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__OptionsFunctionality__printOptions_TIC" c_CasADi__OptionsFunctionality__printOptions_TIC+ :: Ptr OptionsFunctionality' -> IO ()+casADi__OptionsFunctionality__printOptions'+ :: OptionsFunctionality -> IO ()+casADi__OptionsFunctionality__printOptions' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__OptionsFunctionality__printOptions_TIC x0' >>= wrapReturn++-- classy wrapper+optionsFunctionality_printOptions' :: OptionsFunctionalityClass a => a -> IO ()+optionsFunctionality_printOptions' x = casADi__OptionsFunctionality__printOptions' (castOptionsFunctionality x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__OptionsFunctionality__copyOptions" c_CasADi__OptionsFunctionality__copyOptions+ :: Ptr OptionsFunctionality' -> Ptr OptionsFunctionality' -> Ptr CppBool' -> IO ()+casADi__OptionsFunctionality__copyOptions+ :: OptionsFunctionality -> OptionsFunctionality -> Bool -> IO ()+casADi__OptionsFunctionality__copyOptions x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__OptionsFunctionality__copyOptions x0' x1' x2' >>= wrapReturn++-- classy wrapper+{-|+>Copy all options from another object.+-}+optionsFunctionality_copyOptions :: OptionsFunctionalityClass a => a -> OptionsFunctionality -> Bool -> IO ()+optionsFunctionality_copyOptions x = casADi__OptionsFunctionality__copyOptions (castOptionsFunctionality x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__OptionsFunctionality__copyOptions_TIC" c_CasADi__OptionsFunctionality__copyOptions_TIC+ :: Ptr OptionsFunctionality' -> Ptr OptionsFunctionality' -> IO ()+casADi__OptionsFunctionality__copyOptions'+ :: OptionsFunctionality -> OptionsFunctionality -> IO ()+casADi__OptionsFunctionality__copyOptions' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__OptionsFunctionality__copyOptions_TIC x0' x1' >>= wrapReturn++-- classy wrapper+optionsFunctionality_copyOptions' :: OptionsFunctionalityClass a => a -> OptionsFunctionality -> IO ()+optionsFunctionality_copyOptions' x = casADi__OptionsFunctionality__copyOptions' (castOptionsFunctionality x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__OptionsFunctionality__checkNode" c_CasADi__OptionsFunctionality__checkNode+ :: Ptr OptionsFunctionality' -> IO (Ptr CppBool')+casADi__OptionsFunctionality__checkNode+ :: OptionsFunctionality -> IO Bool+casADi__OptionsFunctionality__checkNode x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__OptionsFunctionality__checkNode x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++-- classy wrapper+{-|+>Assert that the node is pointing to the right type of object.+-}+optionsFunctionality_checkNode :: OptionsFunctionalityClass a => a -> IO Bool+optionsFunctionality_checkNode x = casADi__OptionsFunctionality__checkNode (castOptionsFunctionality x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__OptionsFunctionality__getOptionNames" c_CasADi__OptionsFunctionality__getOptionNames+ :: Ptr OptionsFunctionality' -> IO (Ptr (CppVec (Ptr StdString')))+casADi__OptionsFunctionality__getOptionNames+ :: OptionsFunctionality -> IO (Vector String)+casADi__OptionsFunctionality__getOptionNames x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__OptionsFunctionality__getOptionNames x0' >>= (newForeignPtr c_delete_std__vector_std__string_) >>= wrapReturn++-- classy wrapper+{-|+>Get a list of all option names.+-}+optionsFunctionality_getOptionNames :: OptionsFunctionalityClass a => a -> IO (Vector String)+optionsFunctionality_getOptionNames x = casADi__OptionsFunctionality__getOptionNames (castOptionsFunctionality x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__OptionsFunctionality__getOptionDescription" c_CasADi__OptionsFunctionality__getOptionDescription+ :: Ptr OptionsFunctionality' -> Ptr StdString' -> IO (Ptr StdString')+casADi__OptionsFunctionality__getOptionDescription+ :: OptionsFunctionality -> String -> IO String+casADi__OptionsFunctionality__getOptionDescription x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__OptionsFunctionality__getOptionDescription x0' x1' >>= (newForeignPtr c_delete_std__string) >>= wrapReturn++-- classy wrapper+{-|+>Get the description of a certain option.+-}+optionsFunctionality_getOptionDescription :: OptionsFunctionalityClass a => a -> String -> IO String+optionsFunctionality_getOptionDescription x = casADi__OptionsFunctionality__getOptionDescription (castOptionsFunctionality x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__OptionsFunctionality__getOptionType" c_CasADi__OptionsFunctionality__getOptionType+ :: Ptr OptionsFunctionality' -> Ptr StdString' -> IO CInt+casADi__OptionsFunctionality__getOptionType+ :: OptionsFunctionality -> String -> IO Opt_type+casADi__OptionsFunctionality__getOptionType x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__OptionsFunctionality__getOptionType x0' x1' >>= wrapReturn++-- classy wrapper+{-|+>Get the type of a certain option.+-}+optionsFunctionality_getOptionType :: OptionsFunctionalityClass a => a -> String -> IO Opt_type+optionsFunctionality_getOptionType x = casADi__OptionsFunctionality__getOptionType (castOptionsFunctionality x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__OptionsFunctionality__getOptionTypeName" c_CasADi__OptionsFunctionality__getOptionTypeName+ :: Ptr OptionsFunctionality' -> Ptr StdString' -> IO (Ptr StdString')+casADi__OptionsFunctionality__getOptionTypeName+ :: OptionsFunctionality -> String -> IO String+casADi__OptionsFunctionality__getOptionTypeName x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__OptionsFunctionality__getOptionTypeName x0' x1' >>= (newForeignPtr c_delete_std__string) >>= wrapReturn++-- classy wrapper+{-|+>Get the type name of a certain option.+-}+optionsFunctionality_getOptionTypeName :: OptionsFunctionalityClass a => a -> String -> IO String+optionsFunctionality_getOptionTypeName x = casADi__OptionsFunctionality__getOptionTypeName (castOptionsFunctionality x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__OptionsFunctionality__getOptionAllowed" c_CasADi__OptionsFunctionality__getOptionAllowed+ :: Ptr OptionsFunctionality' -> Ptr StdString' -> IO (Ptr (CppVec (Ptr GenericType')))+casADi__OptionsFunctionality__getOptionAllowed+ :: OptionsFunctionality -> String -> IO (Vector GenericType)+casADi__OptionsFunctionality__getOptionAllowed x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__OptionsFunctionality__getOptionAllowed x0' x1' >>= (newForeignPtr c_delete_std__vector_CasADi__GenericType_) >>= wrapReturn++-- classy wrapper+{-|+>Get the allowed values of a certain option.+-}+optionsFunctionality_getOptionAllowed :: OptionsFunctionalityClass a => a -> String -> IO (Vector GenericType)+optionsFunctionality_getOptionAllowed x = casADi__OptionsFunctionality__getOptionAllowed (castOptionsFunctionality x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__OptionsFunctionality__getOptionAllowedIndex" c_CasADi__OptionsFunctionality__getOptionAllowedIndex+ :: Ptr OptionsFunctionality' -> Ptr StdString' -> IO CInt+casADi__OptionsFunctionality__getOptionAllowedIndex+ :: OptionsFunctionality -> String -> IO Int+casADi__OptionsFunctionality__getOptionAllowedIndex x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__OptionsFunctionality__getOptionAllowedIndex x0' x1' >>= wrapReturn++-- classy wrapper+{-|+>Get the index into allowed options of a certain option.+-}+optionsFunctionality_getOptionAllowedIndex :: OptionsFunctionalityClass a => a -> String -> IO Int+optionsFunctionality_getOptionAllowedIndex x = casADi__OptionsFunctionality__getOptionAllowedIndex (castOptionsFunctionality x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__OptionsFunctionality__setOptionByAllowedIndex" c_CasADi__OptionsFunctionality__setOptionByAllowedIndex+ :: Ptr OptionsFunctionality' -> Ptr StdString' -> CInt -> IO ()+casADi__OptionsFunctionality__setOptionByAllowedIndex+ :: OptionsFunctionality -> String -> Int -> IO ()+casADi__OptionsFunctionality__setOptionByAllowedIndex x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__OptionsFunctionality__setOptionByAllowedIndex x0' x1' x2' >>= wrapReturn++-- classy wrapper+{-|+>Set a certain option by giving its index into the allowed values.+-}+optionsFunctionality_setOptionByAllowedIndex :: OptionsFunctionalityClass a => a -> String -> Int -> IO ()+optionsFunctionality_setOptionByAllowedIndex x = casADi__OptionsFunctionality__setOptionByAllowedIndex (castOptionsFunctionality x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__OptionsFunctionality__getOptionEnumValue" c_CasADi__OptionsFunctionality__getOptionEnumValue+ :: Ptr OptionsFunctionality' -> Ptr StdString' -> IO CInt+casADi__OptionsFunctionality__getOptionEnumValue+ :: OptionsFunctionality -> String -> IO Int+casADi__OptionsFunctionality__getOptionEnumValue x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__OptionsFunctionality__getOptionEnumValue x0' x1' >>= wrapReturn++-- classy wrapper+{-|+>Get the enum value corresponding to th certain option.+-}+optionsFunctionality_getOptionEnumValue :: OptionsFunctionalityClass a => a -> String -> IO Int+optionsFunctionality_getOptionEnumValue x = casADi__OptionsFunctionality__getOptionEnumValue (castOptionsFunctionality x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__OptionsFunctionality__setOptionByEnumValue" c_CasADi__OptionsFunctionality__setOptionByEnumValue+ :: Ptr OptionsFunctionality' -> Ptr StdString' -> CInt -> IO ()+casADi__OptionsFunctionality__setOptionByEnumValue+ :: OptionsFunctionality -> String -> Int -> IO ()+casADi__OptionsFunctionality__setOptionByEnumValue x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__OptionsFunctionality__setOptionByEnumValue x0' x1' x2' >>= wrapReturn++-- classy wrapper+{-|+>Set a certain option by giving an enum value.+-}+optionsFunctionality_setOptionByEnumValue :: OptionsFunctionalityClass a => a -> String -> Int -> IO ()+optionsFunctionality_setOptionByEnumValue x = casADi__OptionsFunctionality__setOptionByEnumValue (castOptionsFunctionality x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__OptionsFunctionality__getOptionDefault" c_CasADi__OptionsFunctionality__getOptionDefault+ :: Ptr OptionsFunctionality' -> Ptr StdString' -> IO (Ptr GenericType')+casADi__OptionsFunctionality__getOptionDefault+ :: OptionsFunctionality -> String -> IO GenericType+casADi__OptionsFunctionality__getOptionDefault x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__OptionsFunctionality__getOptionDefault x0' x1' >>= (newForeignPtr c_delete_CasADi__GenericType) >>= wrapReturn++-- classy wrapper+{-|+>Get the default of a certain option.+-}+optionsFunctionality_getOptionDefault :: OptionsFunctionalityClass a => a -> String -> IO GenericType+optionsFunctionality_getOptionDefault x = casADi__OptionsFunctionality__getOptionDefault (castOptionsFunctionality x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__OptionsFunctionality__OptionsFunctionality" c_CasADi__OptionsFunctionality__OptionsFunctionality+ :: IO (Ptr OptionsFunctionality')+casADi__OptionsFunctionality__OptionsFunctionality+ :: IO OptionsFunctionality+casADi__OptionsFunctionality__OptionsFunctionality =+ c_CasADi__OptionsFunctionality__OptionsFunctionality >>= (newForeignPtr c_delete_CasADi__OptionsFunctionality) >>= wrapReturn++-- classy wrapper+{-|+>Default constructor.+-}+optionsFunctionality :: IO OptionsFunctionality+optionsFunctionality = casADi__OptionsFunctionality__OptionsFunctionality+
+ Casadi/Wrappers/Classes/PrintableObject.hs view
@@ -0,0 +1,68 @@+{-# OPTIONS_GHC -Wall #-}+{-# OPTIONS_GHC -fno-warn-unused-imports #-}+{-# OPTIONS_GHC -fno-warn-orphans #-}+{-# Language ForeignFunctionInterface #-}+{-# Language FlexibleInstances #-}+{-# Language MultiParamTypeClasses #-}++module Casadi.Wrappers.Classes.PrintableObject+ (+ PrintableObject,+ PrintableObjectClass(..),+ printableObject_getDescription,+ printableObject_getRepresentation,+ ) 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.ForeignToolsInstances ( )+import Casadi.Wrappers.Deleters+import Casadi.Wrappers.Data+import Casadi.Wrappers.Enums+import Casadi.MarshalTypes ( CppVec, CppVecVec, CppVecVecVec,+ StdString', CppBool' ) -- StdOstream'+import Casadi.Marshal ( CornerCase(..), Marshal(..) )+import Casadi.WrapReturn ( WrapReturn(..) )++instance Show PrintableObject where+ show = unsafePerformIO . printableObject_getDescription+-- direct wrapper+foreign import ccall unsafe "CasADi__PrintableObject__getRepresentation" c_CasADi__PrintableObject__getRepresentation+ :: Ptr PrintableObject' -> IO (Ptr StdString')+casADi__PrintableObject__getRepresentation+ :: PrintableObject -> IO String+casADi__PrintableObject__getRepresentation x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__PrintableObject__getRepresentation x0' >>= (newForeignPtr c_delete_std__string) >>= wrapReturn++-- classy wrapper+{-|+>Return a string with a representation (for SWIG)+-}+printableObject_getRepresentation :: PrintableObjectClass a => a -> IO String+printableObject_getRepresentation x = casADi__PrintableObject__getRepresentation (castPrintableObject x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__PrintableObject__getDescription" c_CasADi__PrintableObject__getDescription+ :: Ptr PrintableObject' -> IO (Ptr StdString')+casADi__PrintableObject__getDescription+ :: PrintableObject -> IO String+casADi__PrintableObject__getDescription x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__PrintableObject__getDescription x0' >>= (newForeignPtr c_delete_std__string) >>= wrapReturn++-- classy wrapper+{-|+>Return a string with a destription (for SWIG)+-}+printableObject_getDescription :: PrintableObjectClass a => a -> IO String+printableObject_getDescription x = casADi__PrintableObject__getDescription (castPrintableObject x)+
+ Casadi/Wrappers/Classes/SX.hs view
@@ -0,0 +1,1604 @@+{-# 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.ForeignToolsInstances ( )+import Casadi.Wrappers.Deleters+import Casadi.Wrappers.Data+import Casadi.Wrappers.Enums+import Casadi.MarshalTypes ( CppVec, CppVecVec, CppVecVecVec,+ StdString', CppBool' ) -- StdOstream'+import Casadi.Marshal ( CornerCase(..), Marshal(..) )+import Casadi.WrapReturn ( WrapReturn(..) )++-- 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' >>= (newForeignPtr c_delete_CasADi__SX) >>= 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' >>= (newForeignPtr c_delete_CasADi__SX) >>= 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 (Ptr CppBool')+casADi__SX____nonzero__+ :: SX -> IO Bool+casADi__SX____nonzero__ x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__SX____nonzero__ x0' >>= (newForeignPtr c_delete_bool) >>= 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 (Ptr CppBool')+casADi__SX__isLeaf+ :: SX -> IO Bool+casADi__SX__isLeaf x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__SX__isLeaf x0' >>= (newForeignPtr c_delete_bool) >>= 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 (Ptr CppBool')+casADi__SX__isConstant+ :: SX -> IO Bool+casADi__SX__isConstant x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__SX__isConstant x0' >>= (newForeignPtr c_delete_bool) >>= 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 (Ptr CppBool')+casADi__SX__isInteger+ :: SX -> IO Bool+casADi__SX__isInteger x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__SX__isInteger x0' >>= (newForeignPtr c_delete_bool) >>= 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 (Ptr CppBool')+casADi__SX__isSymbolic+ :: SX -> IO Bool+casADi__SX__isSymbolic x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__SX__isSymbolic x0' >>= (newForeignPtr c_delete_bool) >>= 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 (Ptr CppBool')+casADi__SX__hasDep+ :: SX -> IO Bool+casADi__SX__hasDep x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__SX__hasDep x0' >>= (newForeignPtr c_delete_bool) >>= 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 (Ptr CppBool')+casADi__SX__isCommutative+ :: SX -> IO Bool+casADi__SX__isCommutative x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__SX__isCommutative x0' >>= (newForeignPtr c_delete_bool) >>= 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 (Ptr CppBool')+casADi__SX__isZero+ :: SX -> IO Bool+casADi__SX__isZero x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__SX__isZero x0' >>= (newForeignPtr c_delete_bool) >>= 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 (Ptr CppBool')+casADi__SX__isOne+ :: SX -> IO Bool+casADi__SX__isOne x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__SX__isOne x0' >>= (newForeignPtr c_delete_bool) >>= 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 (Ptr CppBool')+casADi__SX__isMinusOne+ :: SX -> IO Bool+casADi__SX__isMinusOne x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__SX__isMinusOne x0' >>= (newForeignPtr c_delete_bool) >>= 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 (Ptr CppBool')+casADi__SX__isNan+ :: SX -> IO Bool+casADi__SX__isNan x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__SX__isNan x0' >>= (newForeignPtr c_delete_bool) >>= 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 (Ptr CppBool')+casADi__SX__isInf+ :: SX -> IO Bool+casADi__SX__isInf x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__SX__isInf x0' >>= (newForeignPtr c_delete_bool) >>= 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 (Ptr CppBool')+casADi__SX__isMinusInf+ :: SX -> IO Bool+casADi__SX__isMinusInf x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__SX__isMinusInf x0' >>= (newForeignPtr c_delete_bool) >>= 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 (Ptr CppBool')+casADi__SX__isOp+ :: SX -> Int -> IO Bool+casADi__SX__isOp x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__SX__isOp x0' x1' >>= (newForeignPtr c_delete_bool) >>= 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 (Ptr CppBool')+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' >>= (newForeignPtr c_delete_bool) >>= 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 (Ptr CppBool')+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' >>= (newForeignPtr c_delete_bool) >>= 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 (Ptr CppBool')+casADi__SX__isNonNegative+ :: SX -> IO Bool+casADi__SX__isNonNegative x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__SX__isNonNegative x0' >>= (newForeignPtr c_delete_bool) >>= 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' >>= (newForeignPtr c_delete_CasADi__SX) >>= 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' >>= (newForeignPtr c_delete_CasADi__SX) >>= 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 (Ptr CppBool')+casADi__SX__isDoubled+ :: SX -> IO Bool+casADi__SX__isDoubled x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__SX__isDoubled x0' >>= (newForeignPtr c_delete_bool) >>= 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' >>= (newForeignPtr c_delete_CasADi__SX) >>= 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' >>= (newForeignPtr c_delete_CasADi__SX) >>= 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' >>= (newForeignPtr c_delete_CasADi__SX) >>= 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' >>= (newForeignPtr c_delete_CasADi__SX) >>= 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' >>= (newForeignPtr c_delete_CasADi__SX) >>= 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' >>= (newForeignPtr c_delete_CasADi__SX) >>= 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' >>= (newForeignPtr c_delete_CasADi__SX) >>= 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' >>= (newForeignPtr c_delete_CasADi__SX) >>= 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' >>= (newForeignPtr c_delete_CasADi__SX) >>= 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' >>= (newForeignPtr c_delete_CasADi__SX) >>= 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' >>= (newForeignPtr c_delete_CasADi__SX) >>= 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' >>= (newForeignPtr c_delete_CasADi__SX) >>= 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' >>= (newForeignPtr c_delete_CasADi__SX) >>= 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' >>= (newForeignPtr c_delete_CasADi__SX) >>= 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' >>= (newForeignPtr c_delete_CasADi__SX) >>= 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' >>= (newForeignPtr c_delete_CasADi__SX) >>= 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' >>= (newForeignPtr c_delete_CasADi__SX) >>= 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' >>= (newForeignPtr c_delete_CasADi__SX) >>= 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' >>= (newForeignPtr c_delete_CasADi__SX) >>= 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' >>= (newForeignPtr c_delete_CasADi__SX) >>= 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' >>= (newForeignPtr c_delete_CasADi__SX) >>= 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' >>= (newForeignPtr c_delete_CasADi__SX) >>= 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' >>= (newForeignPtr c_delete_CasADi__SX) >>= 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' >>= (newForeignPtr c_delete_CasADi__SX) >>= 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' >>= (newForeignPtr c_delete_CasADi__SX) >>= 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' >>= (newForeignPtr c_delete_CasADi__SX) >>= 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' >>= (newForeignPtr c_delete_CasADi__SX) >>= 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' >>= (newForeignPtr c_delete_CasADi__SX) >>= 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' >>= (newForeignPtr c_delete_CasADi__SX) >>= 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' >>= (newForeignPtr c_delete_CasADi__SX) >>= 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' >>= (newForeignPtr c_delete_CasADi__SX) >>= 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' >>= (newForeignPtr c_delete_CasADi__SX) >>= 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' >>= (newForeignPtr c_delete_CasADi__SX) >>= 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' >>= (newForeignPtr c_delete_CasADi__SX) >>= 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' >>= (newForeignPtr c_delete_CasADi__SX) >>= 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' >>= (newForeignPtr c_delete_CasADi__SX) >>= 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' >>= (newForeignPtr c_delete_CasADi__SX) >>= 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' >>= (newForeignPtr c_delete_CasADi__SX) >>= 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' >>= (newForeignPtr c_delete_CasADi__SX) >>= 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' >>= (newForeignPtr c_delete_CasADi__SX) >>= 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' >>= (newForeignPtr c_delete_CasADi__SX) >>= 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' >>= (newForeignPtr c_delete_CasADi__SX) >>= 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' >>= (newForeignPtr c_delete_CasADi__SX) >>= 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' >>= (newForeignPtr c_delete_CasADi__SX) >>= 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' >>= (newForeignPtr c_delete_CasADi__SX) >>= 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' >>= (newForeignPtr c_delete_CasADi__SX) >>= 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' >>= (newForeignPtr c_delete_CasADi__SX) >>= 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' >>= (newForeignPtr c_delete_CasADi__SX) >>= 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' >>= (newForeignPtr c_delete_CasADi__SX) >>= 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' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= 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' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= 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' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= 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' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= 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 (Ptr CppBool')+casADi__SX__marked+ :: SX -> IO Bool+casADi__SX__marked x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__SX__marked x0' >>= (newForeignPtr c_delete_bool) >>= 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 (Ptr CppBool')+casADi__SX__isNull+ :: SX -> IO Bool+casADi__SX__isNull x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__SX__isNull x0' >>= (newForeignPtr c_delete_bool) >>= 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 >>= (newForeignPtr c_delete_CasADi__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' >>= (newForeignPtr c_delete_CasADi__SX) >>= 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' >>= (newForeignPtr c_delete_CasADi__SX) >>= wrapReturn++-- classy wrapper+sx'' :: String -> IO SX+sx'' = casADi__SX__SX''+
+ Casadi/Wrappers/Classes/SXFunction.hs view
@@ -0,0 +1,304 @@+{-# OPTIONS_GHC -Wall #-}+{-# OPTIONS_GHC -fno-warn-unused-imports #-}+{-# OPTIONS_GHC -fno-warn-orphans #-}+{-# Language ForeignFunctionInterface #-}+{-# Language FlexibleInstances #-}+{-# Language MultiParamTypeClasses #-}++module Casadi.Wrappers.Classes.SXFunction+ (+ SXFunction,+ SXFunctionClass(..),+ sxFunction',+ sxFunction'',+ sxFunction''',+ sxFunction_countNodes,+ sxFunction_getAlgorithmSize,+ sxFunction_getAtomicInputReal,+ sxFunction_getAtomicOperation,+ sxFunction_getAtomicOutput,+ sxFunction_getFree,+ sxFunction_getWorkSize,+ sxFunction_grad,+ sxFunction_hess,+ sxFunction_indexed_one_based,+ sxFunction_indexed_zero_based,+ sxFunction_jac,+ ) where+++import Prelude hiding ( Functor )++import Data.Vector ( Vector )+import Foreign.C.Types+import Foreign.Ptr ( Ptr )+import Foreign.ForeignPtr ( newForeignPtr )+import System.IO.Unsafe ( unsafePerformIO ) -- for show instances++import Casadi.Wrappers.Classes.PrintableObject+import Casadi.Wrappers.ForeignToolsInstances ( )+import Casadi.Wrappers.Deleters+import Casadi.Wrappers.Data+import Casadi.Wrappers.Enums+import Casadi.MarshalTypes ( CppVec, CppVecVec, CppVecVecVec,+ StdString', CppBool' ) -- StdOstream'+import Casadi.Marshal ( CornerCase(..), Marshal(..) )+import Casadi.WrapReturn ( WrapReturn(..) )++instance Show SXFunction where+ show = unsafePerformIO . printableObject_getDescription+-- direct wrapper+foreign import ccall unsafe "CasADi__SXFunction__jac" c_CasADi__SXFunction__jac+ :: Ptr SXFunction' -> CInt -> CInt -> Ptr CppBool' -> Ptr CppBool' -> IO (Ptr SXMatrix')+casADi__SXFunction__jac+ :: SXFunction -> Int -> Int -> Bool -> Bool -> IO SXMatrix+casADi__SXFunction__jac x0 x1 x2 x3 x4 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ withMarshal x3 $ \x3' ->+ withMarshal x4 $ \x4' ->+ c_CasADi__SXFunction__jac x0' x1' x2' x3' x4' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++-- classy wrapper+{-|+>Jacobian via source code transformation.+>+>See: CasADi::Jacobian for an AD approach+-}+sxFunction_jac :: SXFunctionClass a => a -> Int -> Int -> Bool -> Bool -> IO SXMatrix+sxFunction_jac x = casADi__SXFunction__jac (castSXFunction x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__SXFunction__grad" c_CasADi__SXFunction__grad+ :: Ptr SXFunction' -> CInt -> CInt -> IO (Ptr SXMatrix')+casADi__SXFunction__grad+ :: SXFunction -> Int -> Int -> IO SXMatrix+casADi__SXFunction__grad x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__SXFunction__grad x0' x1' x2' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++-- classy wrapper+{-|+>Gradient via source code transformation.+-}+sxFunction_grad :: SXFunctionClass a => a -> Int -> Int -> IO SXMatrix+sxFunction_grad x = casADi__SXFunction__grad (castSXFunction x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__SXFunction__hess" c_CasADi__SXFunction__hess+ :: Ptr SXFunction' -> CInt -> CInt -> IO (Ptr SXMatrix')+casADi__SXFunction__hess+ :: SXFunction -> Int -> Int -> IO SXMatrix+casADi__SXFunction__hess x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__SXFunction__hess x0' x1' x2' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++-- classy wrapper+{-|+>Hessian (forward over adjoint) via source code transformation.+-}+sxFunction_hess :: SXFunctionClass a => a -> Int -> Int -> IO SXMatrix+sxFunction_hess x = casADi__SXFunction__hess (castSXFunction x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__SXFunction__getAlgorithmSize" c_CasADi__SXFunction__getAlgorithmSize+ :: Ptr SXFunction' -> IO CInt+casADi__SXFunction__getAlgorithmSize+ :: SXFunction -> IO Int+casADi__SXFunction__getAlgorithmSize x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__SXFunction__getAlgorithmSize x0' >>= wrapReturn++-- classy wrapper+{-|+>Get the number of atomic operations.+-}+sxFunction_getAlgorithmSize :: SXFunctionClass a => a -> IO Int+sxFunction_getAlgorithmSize x = casADi__SXFunction__getAlgorithmSize (castSXFunction x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__SXFunction__getWorkSize" c_CasADi__SXFunction__getWorkSize+ :: Ptr SXFunction' -> IO CInt+casADi__SXFunction__getWorkSize+ :: SXFunction -> IO Int+casADi__SXFunction__getWorkSize x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__SXFunction__getWorkSize x0' >>= wrapReturn++-- classy wrapper+{-|+>Get the length of the work vector.+-}+sxFunction_getWorkSize :: SXFunctionClass a => a -> IO Int+sxFunction_getWorkSize x = casADi__SXFunction__getWorkSize (castSXFunction x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__SXFunction__getAtomicOperation" c_CasADi__SXFunction__getAtomicOperation+ :: Ptr SXFunction' -> CInt -> IO CInt+casADi__SXFunction__getAtomicOperation+ :: SXFunction -> Int -> IO Int+casADi__SXFunction__getAtomicOperation x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__SXFunction__getAtomicOperation x0' x1' >>= wrapReturn++-- classy wrapper+{-|+>Get an atomic operation operator index.+-}+sxFunction_getAtomicOperation :: SXFunctionClass a => a -> Int -> IO Int+sxFunction_getAtomicOperation x = casADi__SXFunction__getAtomicOperation (castSXFunction x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__SXFunction__getAtomicInputReal" c_CasADi__SXFunction__getAtomicInputReal+ :: Ptr SXFunction' -> CInt -> IO CDouble+casADi__SXFunction__getAtomicInputReal+ :: SXFunction -> Int -> IO Double+casADi__SXFunction__getAtomicInputReal x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__SXFunction__getAtomicInputReal x0' x1' >>= wrapReturn++-- classy wrapper+{-|+>Get the floating point output argument of an atomic operation.+-}+sxFunction_getAtomicInputReal :: SXFunctionClass a => a -> Int -> IO Double+sxFunction_getAtomicInputReal x = casADi__SXFunction__getAtomicInputReal (castSXFunction x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__SXFunction__getAtomicOutput" c_CasADi__SXFunction__getAtomicOutput+ :: Ptr SXFunction' -> CInt -> IO CInt+casADi__SXFunction__getAtomicOutput+ :: SXFunction -> Int -> IO Int+casADi__SXFunction__getAtomicOutput x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__SXFunction__getAtomicOutput x0' x1' >>= wrapReturn++-- classy wrapper+{-|+>Get the (integer) output argument of an atomic operation.+-}+sxFunction_getAtomicOutput :: SXFunctionClass a => a -> Int -> IO Int+sxFunction_getAtomicOutput x = casADi__SXFunction__getAtomicOutput (castSXFunction x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__SXFunction__countNodes" c_CasADi__SXFunction__countNodes+ :: Ptr SXFunction' -> IO CInt+casADi__SXFunction__countNodes+ :: SXFunction -> IO Int+casADi__SXFunction__countNodes x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__SXFunction__countNodes x0' >>= wrapReturn++-- classy wrapper+{-|+>Number of nodes in the algorithm.+-}+sxFunction_countNodes :: SXFunctionClass a => a -> IO Int+sxFunction_countNodes x = casADi__SXFunction__countNodes (castSXFunction x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__SXFunction__getFree" c_CasADi__SXFunction__getFree+ :: Ptr SXFunction' -> IO (Ptr (CppVec (Ptr SX')))+casADi__SXFunction__getFree+ :: SXFunction -> IO (Vector SX)+casADi__SXFunction__getFree x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__SXFunction__getFree x0' >>= (newForeignPtr c_delete_std__vector_CasADi__SX_) >>= wrapReturn++-- classy wrapper+{-|+>Get all the free variables of the function.+-}+sxFunction_getFree :: SXFunctionClass a => a -> IO (Vector SX)+sxFunction_getFree x = casADi__SXFunction__getFree (castSXFunction x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__SXFunction__indexed_one_based" c_CasADi__SXFunction__indexed_one_based+ :: Ptr SXFunction' -> CInt -> IO (Ptr SXFunction')+casADi__SXFunction__indexed_one_based+ :: SXFunction -> Int -> IO SXFunction+casADi__SXFunction__indexed_one_based x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__SXFunction__indexed_one_based x0' x1' >>= (newForeignPtr c_delete_CasADi__SXFunction) >>= wrapReturn++-- classy wrapper+sxFunction_indexed_one_based :: SXFunctionClass a => a -> Int -> IO SXFunction+sxFunction_indexed_one_based x = casADi__SXFunction__indexed_one_based (castSXFunction x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__SXFunction__indexed_zero_based" c_CasADi__SXFunction__indexed_zero_based+ :: Ptr SXFunction' -> CInt -> IO (Ptr SXFunction')+casADi__SXFunction__indexed_zero_based+ :: SXFunction -> Int -> IO SXFunction+casADi__SXFunction__indexed_zero_based x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__SXFunction__indexed_zero_based x0' x1' >>= (newForeignPtr c_delete_CasADi__SXFunction) >>= wrapReturn++-- classy wrapper+sxFunction_indexed_zero_based :: SXFunctionClass a => a -> Int -> IO SXFunction+sxFunction_indexed_zero_based x = casADi__SXFunction__indexed_zero_based (castSXFunction x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__SXFunction__SXFunction_TIC" c_CasADi__SXFunction__SXFunction_TIC+ :: Ptr MXFunction' -> IO (Ptr SXFunction')+casADi__SXFunction__SXFunction'+ :: MXFunction -> IO SXFunction+casADi__SXFunction__SXFunction' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__SXFunction__SXFunction_TIC x0' >>= (newForeignPtr c_delete_CasADi__SXFunction) >>= wrapReturn++-- classy wrapper+sxFunction' :: MXFunction -> IO SXFunction+sxFunction' = casADi__SXFunction__SXFunction'+++-- direct wrapper+foreign import ccall unsafe "CasADi__SXFunction__SXFunction_TIC_TIC" c_CasADi__SXFunction__SXFunction_TIC_TIC+ :: Ptr FX' -> IO (Ptr SXFunction')+casADi__SXFunction__SXFunction''+ :: FX -> IO SXFunction+casADi__SXFunction__SXFunction'' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__SXFunction__SXFunction_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__SXFunction) >>= wrapReturn++-- classy wrapper+sxFunction'' :: FX -> IO SXFunction+sxFunction'' = casADi__SXFunction__SXFunction''+++-- direct wrapper+foreign import ccall unsafe "CasADi__SXFunction__SXFunction_TIC_TIC_TIC" c_CasADi__SXFunction__SXFunction_TIC_TIC_TIC+ :: Ptr (CppVec (Ptr SXMatrix')) -> Ptr (CppVec (Ptr SXMatrix')) -> IO (Ptr SXFunction')+casADi__SXFunction__SXFunction'''+ :: Vector SXMatrix -> Vector SXMatrix -> IO SXFunction+casADi__SXFunction__SXFunction''' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__SXFunction__SXFunction_TIC_TIC_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__SXFunction) >>= wrapReturn++-- classy wrapper+sxFunction''' :: Vector SXMatrix -> Vector SXMatrix -> IO SXFunction+sxFunction''' = casADi__SXFunction__SXFunction'''+
+ Casadi/Wrappers/Classes/SXMatrix.hs view
@@ -0,0 +1,2681 @@+{-# OPTIONS_GHC -Wall #-}+{-# OPTIONS_GHC -fno-warn-unused-imports #-}+{-# OPTIONS_GHC -fno-warn-orphans #-}+{-# Language ForeignFunctionInterface #-}+{-# Language FlexibleInstances #-}+{-# Language MultiParamTypeClasses #-}++module Casadi.Wrappers.Classes.SXMatrix+ (+ SXMatrix,+ SXMatrixClass(..),+ sxMatrix,+ sxMatrix',+ sxMatrix'',+ sxMatrix''',+ sxMatrix'''',+ sxMatrix''''',+ sxMatrix'''''',+ sxMatrix''''''',+ sxMatrix'''''''',+ sxMatrix''''''''',+ sxMatrix'''''''''',+ sxMatrix''''''''''',+ sxMatrix'''''''''''',+ sxMatrix___add__,+ sxMatrix___constpow__,+ sxMatrix___div__,+ sxMatrix___eq__,+ sxMatrix___le__,+ sxMatrix___lt__,+ sxMatrix___mpower__,+ sxMatrix___mrdivide__,+ sxMatrix___mul__,+ sxMatrix___ne__,+ sxMatrix___nonzero__,+ sxMatrix___pow__,+ sxMatrix___sub__,+ sxMatrix___truediv__,+ sxMatrix_append,+ sxMatrix_arccos,+ sxMatrix_arccosh,+ sxMatrix_arcsin,+ sxMatrix_arcsinh,+ sxMatrix_arctan,+ sxMatrix_arctan2,+ sxMatrix_arctanh,+ sxMatrix_at,+ sxMatrix_binary,+ sxMatrix_ceil,+ sxMatrix_className,+ sxMatrix_clear,+ sxMatrix_col,+ sxMatrix_cos,+ sxMatrix_cosh,+ sxMatrix_data,+ sxMatrix_elem,+ sxMatrix_elem',+ sxMatrix_enlarge,+ sxMatrix_erase,+ sxMatrix_erf,+ sxMatrix_erfinv,+ sxMatrix_exp,+ sxMatrix_eye,+ sxMatrix_fabs,+ sxMatrix_floor,+ sxMatrix_fmax,+ sxMatrix_fmin,+ sxMatrix_get,+ sxMatrix_get',+ sxMatrix_get'',+ sxMatrix_get''',+ sxMatrix_get'''',+ sxMatrix_get''''',+ sxMatrix_hasNZ,+ sxMatrix_if_else_zero,+ sxMatrix_inf,+ sxMatrix_inf',+ sxMatrix_inf'',+ sxMatrix_inf''',+ sxMatrix_isNull,+ sxMatrix_log,+ sxMatrix_log10,+ sxMatrix_logic_and,+ sxMatrix_logic_not,+ sxMatrix_logic_or,+ sxMatrix_matrix_matrix,+ sxMatrix_matrix_scalar,+ sxMatrix_mul,+ sxMatrix_mul',+ sxMatrix_mul_full,+ sxMatrix_mul_full',+ sxMatrix_mul_no_alloc_nn,+ sxMatrix_mul_no_alloc_nn',+ sxMatrix_mul_no_alloc_nt,+ sxMatrix_mul_no_alloc_tn,+ sxMatrix_mul_no_alloc_tn',+ sxMatrix_nan,+ sxMatrix_nan',+ sxMatrix_nan'',+ sxMatrix_nan''',+ sxMatrix_numel,+ sxMatrix_ones,+ sxMatrix_ones',+ sxMatrix_ones'',+ sxMatrix_operator_minus,+ sxMatrix_operator_plus,+ sxMatrix_printDense',+ sxMatrix_printMatrix',+ sxMatrix_printScalar',+ sxMatrix_printSparse',+ sxMatrix_printVector',+ sxMatrix_printme,+ sxMatrix_quad_form,+ sxMatrix_remove,+ sxMatrix_repmat,+ sxMatrix_repmat',+ sxMatrix_reserve,+ sxMatrix_reserve',+ sxMatrix_resize,+ sxMatrix_rowind,+ sxMatrix_sanityCheck,+ sxMatrix_sanityCheck',+ sxMatrix_scalar_matrix,+ sxMatrix_set,+ sxMatrix_set',+ sxMatrix_set'',+ sxMatrix_set''',+ sxMatrix_set'''',+ sxMatrix_set''''',+ sxMatrix_setPrecision,+ sxMatrix_setScientific,+ sxMatrix_setWidth,+ sxMatrix_sign,+ sxMatrix_sin,+ sxMatrix_sinh,+ sxMatrix_size,+ sxMatrix_size1,+ sxMatrix_size2,+ sxMatrix_sparse,+ sxMatrix_sparse',+ sxMatrix_sparse'',+ sxMatrix_sparse''',+ sxMatrix_sparsityRef,+ sxMatrix_sqrt,+ sxMatrix_tan,+ sxMatrix_tanh,+ sxMatrix_trans,+ sxMatrix_unary,+ sxMatrix_vector,+ sxMatrix_zeros,+ sxMatrix_zeros',+ sxMatrix_zeros'',+ ) where+++import Prelude hiding ( Functor )++import Data.Vector ( Vector )+import Foreign.C.Types+import Foreign.Ptr ( Ptr )+import Foreign.ForeignPtr ( newForeignPtr )+import System.IO.Unsafe ( unsafePerformIO ) -- for show instances++import Casadi.Wrappers.Classes.PrintableObject+import Casadi.Wrappers.ForeignToolsInstances ( )+import Casadi.Wrappers.Deleters+import Casadi.Wrappers.Data+import Casadi.Wrappers.Enums+import Casadi.MarshalTypes ( CppVec, CppVecVec, CppVecVecVec,+ StdString', CppBool' ) -- StdOstream'+import Casadi.Marshal ( CornerCase(..), Marshal(..) )+import Casadi.WrapReturn ( WrapReturn(..) )++instance Show SXMatrix where+ show = unsafePerformIO . printableObject_getDescription+-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___size1" c_CasADi__Matrix_CasADi__SX___size1+ :: Ptr SXMatrix' -> IO CInt+casADi__Matrix_CasADi__SX___size1+ :: SXMatrix -> IO Int+casADi__Matrix_CasADi__SX___size1 x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_CasADi__SX___size1 x0' >>= wrapReturn++-- classy wrapper+sxMatrix_size1 :: SXMatrixClass a => a -> IO Int+sxMatrix_size1 x = casADi__Matrix_CasADi__SX___size1 (castSXMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___size2" c_CasADi__Matrix_CasADi__SX___size2+ :: Ptr SXMatrix' -> IO CInt+casADi__Matrix_CasADi__SX___size2+ :: SXMatrix -> IO Int+casADi__Matrix_CasADi__SX___size2 x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_CasADi__SX___size2 x0' >>= wrapReturn++-- classy wrapper+sxMatrix_size2 :: SXMatrixClass a => a -> IO Int+sxMatrix_size2 x = casADi__Matrix_CasADi__SX___size2 (castSXMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___size" c_CasADi__Matrix_CasADi__SX___size+ :: Ptr SXMatrix' -> IO CInt+casADi__Matrix_CasADi__SX___size+ :: SXMatrix -> IO Int+casADi__Matrix_CasADi__SX___size x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_CasADi__SX___size x0' >>= wrapReturn++-- classy wrapper+sxMatrix_size :: SXMatrixClass a => a -> IO Int+sxMatrix_size x = casADi__Matrix_CasADi__SX___size (castSXMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___numel" c_CasADi__Matrix_CasADi__SX___numel+ :: Ptr SXMatrix' -> IO CInt+casADi__Matrix_CasADi__SX___numel+ :: SXMatrix -> IO Int+casADi__Matrix_CasADi__SX___numel x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_CasADi__SX___numel x0' >>= wrapReturn++-- classy wrapper+sxMatrix_numel :: SXMatrixClass a => a -> IO Int+sxMatrix_numel x = casADi__Matrix_CasADi__SX___numel (castSXMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___sanityCheck" c_CasADi__Matrix_CasADi__SX___sanityCheck+ :: Ptr SXMatrix' -> Ptr CppBool' -> IO ()+casADi__Matrix_CasADi__SX___sanityCheck+ :: SXMatrix -> Bool -> IO ()+casADi__Matrix_CasADi__SX___sanityCheck x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__Matrix_CasADi__SX___sanityCheck x0' x1' >>= wrapReturn++-- classy wrapper+{-|+>Check if the dimensions and rowind,col vectors are compatible.+>+>Parameters:+>-----------+>+>complete: set to true to also check elementwise throws an error as possible+>result+-}+sxMatrix_sanityCheck :: SXMatrixClass a => a -> Bool -> IO ()+sxMatrix_sanityCheck x = casADi__Matrix_CasADi__SX___sanityCheck (castSXMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___sanityCheck_TIC" c_CasADi__Matrix_CasADi__SX___sanityCheck_TIC+ :: Ptr SXMatrix' -> IO ()+casADi__Matrix_CasADi__SX___sanityCheck'+ :: SXMatrix -> IO ()+casADi__Matrix_CasADi__SX___sanityCheck' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_CasADi__SX___sanityCheck_TIC x0' >>= wrapReturn++-- classy wrapper+sxMatrix_sanityCheck' :: SXMatrixClass a => a -> IO ()+sxMatrix_sanityCheck' x = casADi__Matrix_CasADi__SX___sanityCheck' (castSXMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___vector" c_CasADi__Matrix_CasADi__SX___vector+ :: Ptr SXMatrix' -> IO (Ptr CppBool')+casADi__Matrix_CasADi__SX___vector+ :: SXMatrix -> IO Bool+casADi__Matrix_CasADi__SX___vector x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_CasADi__SX___vector x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++-- classy wrapper+{-|+>ublas vector+>+>Check type of matrix+-}+sxMatrix_vector :: SXMatrixClass a => a -> IO Bool+sxMatrix_vector x = casADi__Matrix_CasADi__SX___vector (castSXMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___at" c_CasADi__Matrix_CasADi__SX___at+ :: Ptr SXMatrix' -> CInt -> IO (Ptr SX')+casADi__Matrix_CasADi__SX___at+ :: SXMatrix -> Int -> IO SX+casADi__Matrix_CasADi__SX___at x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__Matrix_CasADi__SX___at x0' x1' >>= (newForeignPtr c_delete_CasADi__SX) >>= wrapReturn++-- classy wrapper+{-|+>> const T& CasADi::Matrix< T >::at(int k) const +>------------------------------------------------------------------------+>+>Get a non-zero element.+>+>> T& CasADi::Matrix< T >::at(int k)+>------------------------------------------------------------------------+>+>Access a non-zero element.+-}+sxMatrix_at :: SXMatrixClass a => a -> Int -> IO SX+sxMatrix_at x = casADi__Matrix_CasADi__SX___at (castSXMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___elem" c_CasADi__Matrix_CasADi__SX___elem+ :: Ptr SXMatrix' -> CInt -> CInt -> IO (Ptr SX')+casADi__Matrix_CasADi__SX___elem+ :: SXMatrix -> Int -> Int -> IO SX+casADi__Matrix_CasADi__SX___elem x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__Matrix_CasADi__SX___elem x0' x1' x2' >>= (newForeignPtr c_delete_CasADi__SX) >>= wrapReturn++-- classy wrapper+{-|+>> const T & CasADi::Matrix< T >::elem(int i, int j=0) const +>------------------------------------------------------------------------+>+>get an element+>+>> T & CasADi::Matrix< T >::elem(int i, int j=0)+>------------------------------------------------------------------------+>+>get a reference to an element+-}+sxMatrix_elem :: SXMatrixClass a => a -> Int -> Int -> IO SX+sxMatrix_elem x = casADi__Matrix_CasADi__SX___elem (castSXMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___elem_TIC" c_CasADi__Matrix_CasADi__SX___elem_TIC+ :: Ptr SXMatrix' -> CInt -> IO (Ptr SX')+casADi__Matrix_CasADi__SX___elem'+ :: SXMatrix -> Int -> IO SX+casADi__Matrix_CasADi__SX___elem' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__Matrix_CasADi__SX___elem_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__SX) >>= wrapReturn++-- classy wrapper+sxMatrix_elem' :: SXMatrixClass a => a -> Int -> IO SX+sxMatrix_elem' x = casADi__Matrix_CasADi__SX___elem' (castSXMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___hasNZ" c_CasADi__Matrix_CasADi__SX___hasNZ+ :: Ptr SXMatrix' -> CInt -> CInt -> IO (Ptr CppBool')+casADi__Matrix_CasADi__SX___hasNZ+ :: SXMatrix -> Int -> Int -> IO Bool+casADi__Matrix_CasADi__SX___hasNZ x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__Matrix_CasADi__SX___hasNZ x0' x1' x2' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++-- classy wrapper+{-|+>Returns true if the matrix has a non-zero at location i,j.+-}+sxMatrix_hasNZ :: SXMatrixClass a => a -> Int -> Int -> IO Bool+sxMatrix_hasNZ x = casADi__Matrix_CasADi__SX___hasNZ (castSXMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX_____nonzero__" c_CasADi__Matrix_CasADi__SX_____nonzero__+ :: Ptr SXMatrix' -> IO (Ptr CppBool')+casADi__Matrix_CasADi__SX_____nonzero__+ :: SXMatrix -> IO Bool+casADi__Matrix_CasADi__SX_____nonzero__ x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_CasADi__SX_____nonzero__ x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++-- classy wrapper+{-|+>Returns the truth value of a Matrix.+-}+sxMatrix___nonzero__ :: SXMatrixClass a => a -> IO Bool+sxMatrix___nonzero__ x = casADi__Matrix_CasADi__SX_____nonzero__ (castSXMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___append" c_CasADi__Matrix_CasADi__SX___append+ :: Ptr SXMatrix' -> Ptr SXMatrix' -> IO ()+casADi__Matrix_CasADi__SX___append+ :: SXMatrix -> SXMatrix -> IO ()+casADi__Matrix_CasADi__SX___append x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__Matrix_CasADi__SX___append x0' x1' >>= wrapReturn++-- classy wrapper+{-|+>Append a matrix to the end.+-}+sxMatrix_append :: SXMatrixClass a => a -> SXMatrix -> IO ()+sxMatrix_append x = casADi__Matrix_CasADi__SX___append (castSXMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___operator_plus" c_CasADi__Matrix_CasADi__SX___operator_plus+ :: Ptr SXMatrix' -> IO (Ptr SXMatrix')+casADi__Matrix_CasADi__SX___operator_plus+ :: SXMatrix -> IO SXMatrix+casADi__Matrix_CasADi__SX___operator_plus x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_CasADi__SX___operator_plus x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++-- classy wrapper+sxMatrix_operator_plus :: SXMatrixClass a => a -> IO SXMatrix+sxMatrix_operator_plus x = casADi__Matrix_CasADi__SX___operator_plus (castSXMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___operator_minus" c_CasADi__Matrix_CasADi__SX___operator_minus+ :: Ptr SXMatrix' -> IO (Ptr SXMatrix')+casADi__Matrix_CasADi__SX___operator_minus+ :: SXMatrix -> IO SXMatrix+casADi__Matrix_CasADi__SX___operator_minus x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_CasADi__SX___operator_minus x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++-- classy wrapper+sxMatrix_operator_minus :: SXMatrixClass a => a -> IO SXMatrix+sxMatrix_operator_minus x = casADi__Matrix_CasADi__SX___operator_minus (castSXMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___binary" c_CasADi__Matrix_CasADi__SX___binary+ :: CInt -> Ptr SXMatrix' -> Ptr SXMatrix' -> IO (Ptr SXMatrix')+casADi__Matrix_CasADi__SX___binary+ :: Int -> SXMatrix -> SXMatrix -> IO SXMatrix+casADi__Matrix_CasADi__SX___binary x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__Matrix_CasADi__SX___binary x0' x1' x2' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++-- classy wrapper+{-|+>Create nodes by their ID.+-}+sxMatrix_binary :: Int -> SXMatrix -> SXMatrix -> IO SXMatrix+sxMatrix_binary = casADi__Matrix_CasADi__SX___binary+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___unary" c_CasADi__Matrix_CasADi__SX___unary+ :: CInt -> Ptr SXMatrix' -> IO (Ptr SXMatrix')+casADi__Matrix_CasADi__SX___unary+ :: Int -> SXMatrix -> IO SXMatrix+casADi__Matrix_CasADi__SX___unary x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__Matrix_CasADi__SX___unary x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++-- classy wrapper+{-|+>Create nodes by their ID.+-}+sxMatrix_unary :: Int -> SXMatrix -> IO SXMatrix+sxMatrix_unary = casADi__Matrix_CasADi__SX___unary+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___scalar_matrix" c_CasADi__Matrix_CasADi__SX___scalar_matrix+ :: CInt -> Ptr SXMatrix' -> Ptr SXMatrix' -> IO (Ptr SXMatrix')+casADi__Matrix_CasADi__SX___scalar_matrix+ :: Int -> SXMatrix -> SXMatrix -> IO SXMatrix+casADi__Matrix_CasADi__SX___scalar_matrix x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__Matrix_CasADi__SX___scalar_matrix x0' x1' x2' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++-- classy wrapper+{-|+>Create nodes by their ID.+-}+sxMatrix_scalar_matrix :: Int -> SXMatrix -> SXMatrix -> IO SXMatrix+sxMatrix_scalar_matrix = casADi__Matrix_CasADi__SX___scalar_matrix+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___matrix_scalar" c_CasADi__Matrix_CasADi__SX___matrix_scalar+ :: CInt -> Ptr SXMatrix' -> Ptr SXMatrix' -> IO (Ptr SXMatrix')+casADi__Matrix_CasADi__SX___matrix_scalar+ :: Int -> SXMatrix -> SXMatrix -> IO SXMatrix+casADi__Matrix_CasADi__SX___matrix_scalar x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__Matrix_CasADi__SX___matrix_scalar x0' x1' x2' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++-- classy wrapper+{-|+>Create nodes by their ID.+-}+sxMatrix_matrix_scalar :: Int -> SXMatrix -> SXMatrix -> IO SXMatrix+sxMatrix_matrix_scalar = casADi__Matrix_CasADi__SX___matrix_scalar+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___matrix_matrix" c_CasADi__Matrix_CasADi__SX___matrix_matrix+ :: CInt -> Ptr SXMatrix' -> Ptr SXMatrix' -> IO (Ptr SXMatrix')+casADi__Matrix_CasADi__SX___matrix_matrix+ :: Int -> SXMatrix -> SXMatrix -> IO SXMatrix+casADi__Matrix_CasADi__SX___matrix_matrix x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__Matrix_CasADi__SX___matrix_matrix x0' x1' x2' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++-- classy wrapper+{-|+>Create nodes by their ID.+-}+sxMatrix_matrix_matrix :: Int -> SXMatrix -> SXMatrix -> IO SXMatrix+sxMatrix_matrix_matrix = casADi__Matrix_CasADi__SX___matrix_matrix+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX_____add__" c_CasADi__Matrix_CasADi__SX_____add__+ :: Ptr SXMatrix' -> Ptr SXMatrix' -> IO (Ptr SXMatrix')+casADi__Matrix_CasADi__SX_____add__+ :: SXMatrix -> SXMatrix -> IO SXMatrix+casADi__Matrix_CasADi__SX_____add__ x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__Matrix_CasADi__SX_____add__ x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++-- classy wrapper+{-|+>Elementwise operations Octave/Python naming.+-}+sxMatrix___add__ :: SXMatrixClass a => a -> SXMatrix -> IO SXMatrix+sxMatrix___add__ x = casADi__Matrix_CasADi__SX_____add__ (castSXMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX_____sub__" c_CasADi__Matrix_CasADi__SX_____sub__+ :: Ptr SXMatrix' -> Ptr SXMatrix' -> IO (Ptr SXMatrix')+casADi__Matrix_CasADi__SX_____sub__+ :: SXMatrix -> SXMatrix -> IO SXMatrix+casADi__Matrix_CasADi__SX_____sub__ x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__Matrix_CasADi__SX_____sub__ x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++-- classy wrapper+{-|+>Elementwise operations Octave/Python naming.+-}+sxMatrix___sub__ :: SXMatrixClass a => a -> SXMatrix -> IO SXMatrix+sxMatrix___sub__ x = casADi__Matrix_CasADi__SX_____sub__ (castSXMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX_____mul__" c_CasADi__Matrix_CasADi__SX_____mul__+ :: Ptr SXMatrix' -> Ptr SXMatrix' -> IO (Ptr SXMatrix')+casADi__Matrix_CasADi__SX_____mul__+ :: SXMatrix -> SXMatrix -> IO SXMatrix+casADi__Matrix_CasADi__SX_____mul__ x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__Matrix_CasADi__SX_____mul__ x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++-- classy wrapper+{-|+>Elementwise operations Octave/Python naming.+-}+sxMatrix___mul__ :: SXMatrixClass a => a -> SXMatrix -> IO SXMatrix+sxMatrix___mul__ x = casADi__Matrix_CasADi__SX_____mul__ (castSXMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX_____div__" c_CasADi__Matrix_CasADi__SX_____div__+ :: Ptr SXMatrix' -> Ptr SXMatrix' -> IO (Ptr SXMatrix')+casADi__Matrix_CasADi__SX_____div__+ :: SXMatrix -> SXMatrix -> IO SXMatrix+casADi__Matrix_CasADi__SX_____div__ x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__Matrix_CasADi__SX_____div__ x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++-- classy wrapper+{-|+>Elementwise operations Octave/Python naming.+-}+sxMatrix___div__ :: SXMatrixClass a => a -> SXMatrix -> IO SXMatrix+sxMatrix___div__ x = casADi__Matrix_CasADi__SX_____div__ (castSXMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX_____lt__" c_CasADi__Matrix_CasADi__SX_____lt__+ :: Ptr SXMatrix' -> Ptr SXMatrix' -> IO (Ptr SXMatrix')+casADi__Matrix_CasADi__SX_____lt__+ :: SXMatrix -> SXMatrix -> IO SXMatrix+casADi__Matrix_CasADi__SX_____lt__ x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__Matrix_CasADi__SX_____lt__ x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++-- classy wrapper+{-|+>Elementwise operations Octave/Python naming.+-}+sxMatrix___lt__ :: SXMatrixClass a => a -> SXMatrix -> IO SXMatrix+sxMatrix___lt__ x = casADi__Matrix_CasADi__SX_____lt__ (castSXMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX_____le__" c_CasADi__Matrix_CasADi__SX_____le__+ :: Ptr SXMatrix' -> Ptr SXMatrix' -> IO (Ptr SXMatrix')+casADi__Matrix_CasADi__SX_____le__+ :: SXMatrix -> SXMatrix -> IO SXMatrix+casADi__Matrix_CasADi__SX_____le__ x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__Matrix_CasADi__SX_____le__ x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++-- classy wrapper+{-|+>Elementwise operations Octave/Python naming.+-}+sxMatrix___le__ :: SXMatrixClass a => a -> SXMatrix -> IO SXMatrix+sxMatrix___le__ x = casADi__Matrix_CasADi__SX_____le__ (castSXMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX_____eq__" c_CasADi__Matrix_CasADi__SX_____eq__+ :: Ptr SXMatrix' -> Ptr SXMatrix' -> IO (Ptr SXMatrix')+casADi__Matrix_CasADi__SX_____eq__+ :: SXMatrix -> SXMatrix -> IO SXMatrix+casADi__Matrix_CasADi__SX_____eq__ x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__Matrix_CasADi__SX_____eq__ x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++-- classy wrapper+{-|+>Elementwise operations Octave/Python naming.+-}+sxMatrix___eq__ :: SXMatrixClass a => a -> SXMatrix -> IO SXMatrix+sxMatrix___eq__ x = casADi__Matrix_CasADi__SX_____eq__ (castSXMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX_____ne__" c_CasADi__Matrix_CasADi__SX_____ne__+ :: Ptr SXMatrix' -> Ptr SXMatrix' -> IO (Ptr SXMatrix')+casADi__Matrix_CasADi__SX_____ne__+ :: SXMatrix -> SXMatrix -> IO SXMatrix+casADi__Matrix_CasADi__SX_____ne__ x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__Matrix_CasADi__SX_____ne__ x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++-- classy wrapper+{-|+>Elementwise operations Octave/Python naming.+-}+sxMatrix___ne__ :: SXMatrixClass a => a -> SXMatrix -> IO SXMatrix+sxMatrix___ne__ x = casADi__Matrix_CasADi__SX_____ne__ (castSXMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX_____truediv__" c_CasADi__Matrix_CasADi__SX_____truediv__+ :: Ptr SXMatrix' -> Ptr SXMatrix' -> IO (Ptr SXMatrix')+casADi__Matrix_CasADi__SX_____truediv__+ :: SXMatrix -> SXMatrix -> IO SXMatrix+casADi__Matrix_CasADi__SX_____truediv__ x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__Matrix_CasADi__SX_____truediv__ x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++-- classy wrapper+{-|+>Elementwise operations Octave/Python naming.+-}+sxMatrix___truediv__ :: SXMatrixClass a => a -> SXMatrix -> IO SXMatrix+sxMatrix___truediv__ x = casADi__Matrix_CasADi__SX_____truediv__ (castSXMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX_____pow__" c_CasADi__Matrix_CasADi__SX_____pow__+ :: Ptr SXMatrix' -> Ptr SXMatrix' -> IO (Ptr SXMatrix')+casADi__Matrix_CasADi__SX_____pow__+ :: SXMatrix -> SXMatrix -> IO SXMatrix+casADi__Matrix_CasADi__SX_____pow__ x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__Matrix_CasADi__SX_____pow__ x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++-- classy wrapper+{-|+>Elementwise operations Octave/Python naming.+-}+sxMatrix___pow__ :: SXMatrixClass a => a -> SXMatrix -> IO SXMatrix+sxMatrix___pow__ x = casADi__Matrix_CasADi__SX_____pow__ (castSXMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX_____constpow__" c_CasADi__Matrix_CasADi__SX_____constpow__+ :: Ptr SXMatrix' -> Ptr SXMatrix' -> IO (Ptr SXMatrix')+casADi__Matrix_CasADi__SX_____constpow__+ :: SXMatrix -> SXMatrix -> IO SXMatrix+casADi__Matrix_CasADi__SX_____constpow__ x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__Matrix_CasADi__SX_____constpow__ x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++-- classy wrapper+{-|+>Elementwise operations Octave/Python naming.+-}+sxMatrix___constpow__ :: SXMatrixClass a => a -> SXMatrix -> IO SXMatrix+sxMatrix___constpow__ x = casADi__Matrix_CasADi__SX_____constpow__ (castSXMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX_____mpower__" c_CasADi__Matrix_CasADi__SX_____mpower__+ :: Ptr SXMatrix' -> Ptr SXMatrix' -> IO (Ptr SXMatrix')+casADi__Matrix_CasADi__SX_____mpower__+ :: SXMatrix -> SXMatrix -> IO SXMatrix+casADi__Matrix_CasADi__SX_____mpower__ x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__Matrix_CasADi__SX_____mpower__ x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++-- classy wrapper+{-|+>Elementwise operations Octave/Python naming.+-}+sxMatrix___mpower__ :: SXMatrixClass a => a -> SXMatrix -> IO SXMatrix+sxMatrix___mpower__ x = casADi__Matrix_CasADi__SX_____mpower__ (castSXMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX_____mrdivide__" c_CasADi__Matrix_CasADi__SX_____mrdivide__+ :: Ptr SXMatrix' -> Ptr SXMatrix' -> IO (Ptr SXMatrix')+casADi__Matrix_CasADi__SX_____mrdivide__+ :: SXMatrix -> SXMatrix -> IO SXMatrix+casADi__Matrix_CasADi__SX_____mrdivide__ x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__Matrix_CasADi__SX_____mrdivide__ x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++-- classy wrapper+{-|+>Elementwise operations Octave/Python naming.+-}+sxMatrix___mrdivide__ :: SXMatrixClass a => a -> SXMatrix -> IO SXMatrix+sxMatrix___mrdivide__ x = casADi__Matrix_CasADi__SX_____mrdivide__ (castSXMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___mul_full" c_CasADi__Matrix_CasADi__SX___mul_full+ :: Ptr SXMatrix' -> Ptr SXMatrix' -> Ptr CRSSparsity' -> IO (Ptr SXMatrix')+casADi__Matrix_CasADi__SX___mul_full+ :: SXMatrix -> SXMatrix -> CRSSparsity -> IO SXMatrix+casADi__Matrix_CasADi__SX___mul_full x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__Matrix_CasADi__SX___mul_full x0' x1' x2' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++-- classy wrapper+{-|+>Matrix-matrix product.+-}+sxMatrix_mul_full :: SXMatrixClass a => a -> SXMatrix -> CRSSparsity -> IO SXMatrix+sxMatrix_mul_full x = casADi__Matrix_CasADi__SX___mul_full (castSXMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___mul_full_TIC" c_CasADi__Matrix_CasADi__SX___mul_full_TIC+ :: Ptr SXMatrix' -> Ptr SXMatrix' -> IO (Ptr SXMatrix')+casADi__Matrix_CasADi__SX___mul_full'+ :: SXMatrix -> SXMatrix -> IO SXMatrix+casADi__Matrix_CasADi__SX___mul_full' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__Matrix_CasADi__SX___mul_full_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++-- classy wrapper+sxMatrix_mul_full' :: SXMatrixClass a => a -> SXMatrix -> IO SXMatrix+sxMatrix_mul_full' x = casADi__Matrix_CasADi__SX___mul_full' (castSXMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___mul" c_CasADi__Matrix_CasADi__SX___mul+ :: Ptr SXMatrix' -> Ptr SXMatrix' -> Ptr CRSSparsity' -> IO (Ptr SXMatrix')+casADi__Matrix_CasADi__SX___mul+ :: SXMatrix -> SXMatrix -> CRSSparsity -> IO SXMatrix+casADi__Matrix_CasADi__SX___mul x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__Matrix_CasADi__SX___mul x0' x1' x2' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++-- classy wrapper+{-|+>Matrix-matrix product.+-}+sxMatrix_mul :: SXMatrixClass a => a -> SXMatrix -> CRSSparsity -> IO SXMatrix+sxMatrix_mul x = casADi__Matrix_CasADi__SX___mul (castSXMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___mul_TIC" c_CasADi__Matrix_CasADi__SX___mul_TIC+ :: Ptr SXMatrix' -> Ptr SXMatrix' -> IO (Ptr SXMatrix')+casADi__Matrix_CasADi__SX___mul'+ :: SXMatrix -> SXMatrix -> IO SXMatrix+casADi__Matrix_CasADi__SX___mul' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__Matrix_CasADi__SX___mul_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++-- classy wrapper+sxMatrix_mul' :: SXMatrixClass a => a -> SXMatrix -> IO SXMatrix+sxMatrix_mul' x = casADi__Matrix_CasADi__SX___mul' (castSXMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___mul_no_alloc_nn" c_CasADi__Matrix_CasADi__SX___mul_no_alloc_nn+ :: Ptr SXMatrix' -> Ptr SXMatrix' -> Ptr SXMatrix' -> IO ()+casADi__Matrix_CasADi__SX___mul_no_alloc_nn+ :: SXMatrix -> SXMatrix -> SXMatrix -> IO ()+casADi__Matrix_CasADi__SX___mul_no_alloc_nn x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__Matrix_CasADi__SX___mul_no_alloc_nn x0' x1' x2' >>= wrapReturn++-- classy wrapper+sxMatrix_mul_no_alloc_nn :: SXMatrix -> SXMatrix -> SXMatrix -> IO ()+sxMatrix_mul_no_alloc_nn = casADi__Matrix_CasADi__SX___mul_no_alloc_nn+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___mul_no_alloc_nt" c_CasADi__Matrix_CasADi__SX___mul_no_alloc_nt+ :: Ptr SXMatrix' -> Ptr SXMatrix' -> Ptr SXMatrix' -> IO ()+casADi__Matrix_CasADi__SX___mul_no_alloc_nt+ :: SXMatrix -> SXMatrix -> SXMatrix -> IO ()+casADi__Matrix_CasADi__SX___mul_no_alloc_nt x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__Matrix_CasADi__SX___mul_no_alloc_nt x0' x1' x2' >>= wrapReturn++-- classy wrapper+sxMatrix_mul_no_alloc_nt :: SXMatrix -> SXMatrix -> SXMatrix -> IO ()+sxMatrix_mul_no_alloc_nt = casADi__Matrix_CasADi__SX___mul_no_alloc_nt+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___mul_no_alloc_tn" c_CasADi__Matrix_CasADi__SX___mul_no_alloc_tn+ :: Ptr SXMatrix' -> Ptr SXMatrix' -> Ptr SXMatrix' -> IO ()+casADi__Matrix_CasADi__SX___mul_no_alloc_tn+ :: SXMatrix -> SXMatrix -> SXMatrix -> IO ()+casADi__Matrix_CasADi__SX___mul_no_alloc_tn x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__Matrix_CasADi__SX___mul_no_alloc_tn x0' x1' x2' >>= wrapReturn++-- classy wrapper+sxMatrix_mul_no_alloc_tn :: SXMatrix -> SXMatrix -> SXMatrix -> IO ()+sxMatrix_mul_no_alloc_tn = casADi__Matrix_CasADi__SX___mul_no_alloc_tn+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___mul_no_alloc_nn_TIC" c_CasADi__Matrix_CasADi__SX___mul_no_alloc_nn_TIC+ :: Ptr SXMatrix' -> Ptr (CppVec (Ptr SX')) -> Ptr (CppVec (Ptr SX')) -> IO ()+casADi__Matrix_CasADi__SX___mul_no_alloc_nn'+ :: SXMatrix -> Vector SX -> Vector SX -> IO ()+casADi__Matrix_CasADi__SX___mul_no_alloc_nn' x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__Matrix_CasADi__SX___mul_no_alloc_nn_TIC x0' x1' x2' >>= wrapReturn++-- classy wrapper+sxMatrix_mul_no_alloc_nn' :: SXMatrix -> Vector SX -> Vector SX -> IO ()+sxMatrix_mul_no_alloc_nn' = casADi__Matrix_CasADi__SX___mul_no_alloc_nn'+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___mul_no_alloc_tn_TIC" c_CasADi__Matrix_CasADi__SX___mul_no_alloc_tn_TIC+ :: Ptr SXMatrix' -> Ptr (CppVec (Ptr SX')) -> Ptr (CppVec (Ptr SX')) -> IO ()+casADi__Matrix_CasADi__SX___mul_no_alloc_tn'+ :: SXMatrix -> Vector SX -> Vector SX -> IO ()+casADi__Matrix_CasADi__SX___mul_no_alloc_tn' x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__Matrix_CasADi__SX___mul_no_alloc_tn_TIC x0' x1' x2' >>= wrapReturn++-- classy wrapper+sxMatrix_mul_no_alloc_tn' :: SXMatrix -> Vector SX -> Vector SX -> IO ()+sxMatrix_mul_no_alloc_tn' = casADi__Matrix_CasADi__SX___mul_no_alloc_tn'+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___quad_form" c_CasADi__Matrix_CasADi__SX___quad_form+ :: Ptr SXMatrix' -> Ptr (CppVec (Ptr SX')) -> IO (Ptr SX')+casADi__Matrix_CasADi__SX___quad_form+ :: SXMatrix -> Vector SX -> IO SX+casADi__Matrix_CasADi__SX___quad_form x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__Matrix_CasADi__SX___quad_form x0' x1' >>= (newForeignPtr c_delete_CasADi__SX) >>= wrapReturn++-- classy wrapper+sxMatrix_quad_form :: SXMatrix -> Vector SX -> IO SX+sxMatrix_quad_form = casADi__Matrix_CasADi__SX___quad_form+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___trans" c_CasADi__Matrix_CasADi__SX___trans+ :: Ptr SXMatrix' -> IO (Ptr SXMatrix')+casADi__Matrix_CasADi__SX___trans+ :: SXMatrix -> IO SXMatrix+casADi__Matrix_CasADi__SX___trans x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_CasADi__SX___trans x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++-- classy wrapper+{-|+>Matrix transpose.+-}+sxMatrix_trans :: SXMatrixClass a => a -> IO SXMatrix+sxMatrix_trans x = casADi__Matrix_CasADi__SX___trans (castSXMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___sin" c_CasADi__Matrix_CasADi__SX___sin+ :: Ptr SXMatrix' -> IO (Ptr SXMatrix')+casADi__Matrix_CasADi__SX___sin+ :: SXMatrix -> IO SXMatrix+casADi__Matrix_CasADi__SX___sin x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_CasADi__SX___sin x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++-- classy wrapper+{-|+>Operations defined in the standard namespace for unambigous access and Numpy+>compatibility.+-}+sxMatrix_sin :: SXMatrixClass a => a -> IO SXMatrix+sxMatrix_sin x = casADi__Matrix_CasADi__SX___sin (castSXMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___cos" c_CasADi__Matrix_CasADi__SX___cos+ :: Ptr SXMatrix' -> IO (Ptr SXMatrix')+casADi__Matrix_CasADi__SX___cos+ :: SXMatrix -> IO SXMatrix+casADi__Matrix_CasADi__SX___cos x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_CasADi__SX___cos x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++-- classy wrapper+{-|+>Operations defined in the standard namespace for unambigous access and Numpy+>compatibility.+-}+sxMatrix_cos :: SXMatrixClass a => a -> IO SXMatrix+sxMatrix_cos x = casADi__Matrix_CasADi__SX___cos (castSXMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___tan" c_CasADi__Matrix_CasADi__SX___tan+ :: Ptr SXMatrix' -> IO (Ptr SXMatrix')+casADi__Matrix_CasADi__SX___tan+ :: SXMatrix -> IO SXMatrix+casADi__Matrix_CasADi__SX___tan x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_CasADi__SX___tan x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++-- classy wrapper+{-|+>Operations defined in the standard namespace for unambigous access and Numpy+>compatibility.+-}+sxMatrix_tan :: SXMatrixClass a => a -> IO SXMatrix+sxMatrix_tan x = casADi__Matrix_CasADi__SX___tan (castSXMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___arcsin" c_CasADi__Matrix_CasADi__SX___arcsin+ :: Ptr SXMatrix' -> IO (Ptr SXMatrix')+casADi__Matrix_CasADi__SX___arcsin+ :: SXMatrix -> IO SXMatrix+casADi__Matrix_CasADi__SX___arcsin x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_CasADi__SX___arcsin x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++-- classy wrapper+{-|+>Operations defined in the standard namespace for unambigous access and Numpy+>compatibility.+-}+sxMatrix_arcsin :: SXMatrixClass a => a -> IO SXMatrix+sxMatrix_arcsin x = casADi__Matrix_CasADi__SX___arcsin (castSXMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___arccos" c_CasADi__Matrix_CasADi__SX___arccos+ :: Ptr SXMatrix' -> IO (Ptr SXMatrix')+casADi__Matrix_CasADi__SX___arccos+ :: SXMatrix -> IO SXMatrix+casADi__Matrix_CasADi__SX___arccos x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_CasADi__SX___arccos x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++-- classy wrapper+{-|+>Operations defined in the standard namespace for unambigous access and Numpy+>compatibility.+-}+sxMatrix_arccos :: SXMatrixClass a => a -> IO SXMatrix+sxMatrix_arccos x = casADi__Matrix_CasADi__SX___arccos (castSXMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___arctan" c_CasADi__Matrix_CasADi__SX___arctan+ :: Ptr SXMatrix' -> IO (Ptr SXMatrix')+casADi__Matrix_CasADi__SX___arctan+ :: SXMatrix -> IO SXMatrix+casADi__Matrix_CasADi__SX___arctan x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_CasADi__SX___arctan x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++-- classy wrapper+{-|+>Operations defined in the standard namespace for unambigous access and Numpy+>compatibility.+-}+sxMatrix_arctan :: SXMatrixClass a => a -> IO SXMatrix+sxMatrix_arctan x = casADi__Matrix_CasADi__SX___arctan (castSXMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___exp" c_CasADi__Matrix_CasADi__SX___exp+ :: Ptr SXMatrix' -> IO (Ptr SXMatrix')+casADi__Matrix_CasADi__SX___exp+ :: SXMatrix -> IO SXMatrix+casADi__Matrix_CasADi__SX___exp x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_CasADi__SX___exp x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++-- classy wrapper+{-|+>Operations defined in the standard namespace for unambigous access and Numpy+>compatibility.+-}+sxMatrix_exp :: SXMatrixClass a => a -> IO SXMatrix+sxMatrix_exp x = casADi__Matrix_CasADi__SX___exp (castSXMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___log" c_CasADi__Matrix_CasADi__SX___log+ :: Ptr SXMatrix' -> IO (Ptr SXMatrix')+casADi__Matrix_CasADi__SX___log+ :: SXMatrix -> IO SXMatrix+casADi__Matrix_CasADi__SX___log x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_CasADi__SX___log x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++-- classy wrapper+{-|+>Operations defined in the standard namespace for unambigous access and Numpy+>compatibility.+-}+sxMatrix_log :: SXMatrixClass a => a -> IO SXMatrix+sxMatrix_log x = casADi__Matrix_CasADi__SX___log (castSXMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___sqrt" c_CasADi__Matrix_CasADi__SX___sqrt+ :: Ptr SXMatrix' -> IO (Ptr SXMatrix')+casADi__Matrix_CasADi__SX___sqrt+ :: SXMatrix -> IO SXMatrix+casADi__Matrix_CasADi__SX___sqrt x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_CasADi__SX___sqrt x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++-- classy wrapper+{-|+>Operations defined in the standard namespace for unambigous access and Numpy+>compatibility.+-}+sxMatrix_sqrt :: SXMatrixClass a => a -> IO SXMatrix+sxMatrix_sqrt x = casADi__Matrix_CasADi__SX___sqrt (castSXMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___floor" c_CasADi__Matrix_CasADi__SX___floor+ :: Ptr SXMatrix' -> IO (Ptr SXMatrix')+casADi__Matrix_CasADi__SX___floor+ :: SXMatrix -> IO SXMatrix+casADi__Matrix_CasADi__SX___floor x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_CasADi__SX___floor x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++-- classy wrapper+{-|+>Operations defined in the standard namespace for unambigous access and Numpy+>compatibility.+-}+sxMatrix_floor :: SXMatrixClass a => a -> IO SXMatrix+sxMatrix_floor x = casADi__Matrix_CasADi__SX___floor (castSXMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___ceil" c_CasADi__Matrix_CasADi__SX___ceil+ :: Ptr SXMatrix' -> IO (Ptr SXMatrix')+casADi__Matrix_CasADi__SX___ceil+ :: SXMatrix -> IO SXMatrix+casADi__Matrix_CasADi__SX___ceil x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_CasADi__SX___ceil x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++-- classy wrapper+{-|+>Operations defined in the standard namespace for unambigous access and Numpy+>compatibility.+-}+sxMatrix_ceil :: SXMatrixClass a => a -> IO SXMatrix+sxMatrix_ceil x = casADi__Matrix_CasADi__SX___ceil (castSXMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___fabs" c_CasADi__Matrix_CasADi__SX___fabs+ :: Ptr SXMatrix' -> IO (Ptr SXMatrix')+casADi__Matrix_CasADi__SX___fabs+ :: SXMatrix -> IO SXMatrix+casADi__Matrix_CasADi__SX___fabs x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_CasADi__SX___fabs x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++-- classy wrapper+{-|+>Operations defined in the standard namespace for unambigous access and Numpy+>compatibility.+-}+sxMatrix_fabs :: SXMatrixClass a => a -> IO SXMatrix+sxMatrix_fabs x = casADi__Matrix_CasADi__SX___fabs (castSXMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___sign" c_CasADi__Matrix_CasADi__SX___sign+ :: Ptr SXMatrix' -> IO (Ptr SXMatrix')+casADi__Matrix_CasADi__SX___sign+ :: SXMatrix -> IO SXMatrix+casADi__Matrix_CasADi__SX___sign x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_CasADi__SX___sign x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++-- classy wrapper+{-|+>Operations defined in the standard namespace for unambigous access and Numpy+>compatibility.+-}+sxMatrix_sign :: SXMatrixClass a => a -> IO SXMatrix+sxMatrix_sign x = casADi__Matrix_CasADi__SX___sign (castSXMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___erfinv" c_CasADi__Matrix_CasADi__SX___erfinv+ :: Ptr SXMatrix' -> IO (Ptr SXMatrix')+casADi__Matrix_CasADi__SX___erfinv+ :: SXMatrix -> IO SXMatrix+casADi__Matrix_CasADi__SX___erfinv x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_CasADi__SX___erfinv x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++-- classy wrapper+{-|+>Operations defined in the standard namespace for unambigous access and Numpy+>compatibility.+-}+sxMatrix_erfinv :: SXMatrixClass a => a -> IO SXMatrix+sxMatrix_erfinv x = casADi__Matrix_CasADi__SX___erfinv (castSXMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___fmin" c_CasADi__Matrix_CasADi__SX___fmin+ :: Ptr SXMatrix' -> Ptr SXMatrix' -> IO (Ptr SXMatrix')+casADi__Matrix_CasADi__SX___fmin+ :: SXMatrix -> SXMatrix -> IO SXMatrix+casADi__Matrix_CasADi__SX___fmin x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__Matrix_CasADi__SX___fmin x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++-- classy wrapper+{-|+>Operations defined in the standard namespace for unambigous access and Numpy+>compatibility.+-}+sxMatrix_fmin :: SXMatrixClass a => a -> SXMatrix -> IO SXMatrix+sxMatrix_fmin x = casADi__Matrix_CasADi__SX___fmin (castSXMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___fmax" c_CasADi__Matrix_CasADi__SX___fmax+ :: Ptr SXMatrix' -> Ptr SXMatrix' -> IO (Ptr SXMatrix')+casADi__Matrix_CasADi__SX___fmax+ :: SXMatrix -> SXMatrix -> IO SXMatrix+casADi__Matrix_CasADi__SX___fmax x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__Matrix_CasADi__SX___fmax x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++-- classy wrapper+{-|+>Operations defined in the standard namespace for unambigous access and Numpy+>compatibility.+-}+sxMatrix_fmax :: SXMatrixClass a => a -> SXMatrix -> IO SXMatrix+sxMatrix_fmax x = casADi__Matrix_CasADi__SX___fmax (castSXMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___erf" c_CasADi__Matrix_CasADi__SX___erf+ :: Ptr SXMatrix' -> IO (Ptr SXMatrix')+casADi__Matrix_CasADi__SX___erf+ :: SXMatrix -> IO SXMatrix+casADi__Matrix_CasADi__SX___erf x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_CasADi__SX___erf x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++-- classy wrapper+{-|+>Operations defined in the standard namespace for unambigous access and Numpy+>compatibility.+-}+sxMatrix_erf :: SXMatrixClass a => a -> IO SXMatrix+sxMatrix_erf x = casADi__Matrix_CasADi__SX___erf (castSXMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___sinh" c_CasADi__Matrix_CasADi__SX___sinh+ :: Ptr SXMatrix' -> IO (Ptr SXMatrix')+casADi__Matrix_CasADi__SX___sinh+ :: SXMatrix -> IO SXMatrix+casADi__Matrix_CasADi__SX___sinh x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_CasADi__SX___sinh x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++-- classy wrapper+{-|+>Operations defined in the standard namespace for unambigous access and Numpy+>compatibility.+-}+sxMatrix_sinh :: SXMatrixClass a => a -> IO SXMatrix+sxMatrix_sinh x = casADi__Matrix_CasADi__SX___sinh (castSXMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___cosh" c_CasADi__Matrix_CasADi__SX___cosh+ :: Ptr SXMatrix' -> IO (Ptr SXMatrix')+casADi__Matrix_CasADi__SX___cosh+ :: SXMatrix -> IO SXMatrix+casADi__Matrix_CasADi__SX___cosh x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_CasADi__SX___cosh x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++-- classy wrapper+{-|+>Operations defined in the standard namespace for unambigous access and Numpy+>compatibility.+-}+sxMatrix_cosh :: SXMatrixClass a => a -> IO SXMatrix+sxMatrix_cosh x = casADi__Matrix_CasADi__SX___cosh (castSXMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___tanh" c_CasADi__Matrix_CasADi__SX___tanh+ :: Ptr SXMatrix' -> IO (Ptr SXMatrix')+casADi__Matrix_CasADi__SX___tanh+ :: SXMatrix -> IO SXMatrix+casADi__Matrix_CasADi__SX___tanh x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_CasADi__SX___tanh x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++-- classy wrapper+{-|+>Operations defined in the standard namespace for unambigous access and Numpy+>compatibility.+-}+sxMatrix_tanh :: SXMatrixClass a => a -> IO SXMatrix+sxMatrix_tanh x = casADi__Matrix_CasADi__SX___tanh (castSXMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___arcsinh" c_CasADi__Matrix_CasADi__SX___arcsinh+ :: Ptr SXMatrix' -> IO (Ptr SXMatrix')+casADi__Matrix_CasADi__SX___arcsinh+ :: SXMatrix -> IO SXMatrix+casADi__Matrix_CasADi__SX___arcsinh x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_CasADi__SX___arcsinh x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++-- classy wrapper+{-|+>Operations defined in the standard namespace for unambigous access and Numpy+>compatibility.+-}+sxMatrix_arcsinh :: SXMatrixClass a => a -> IO SXMatrix+sxMatrix_arcsinh x = casADi__Matrix_CasADi__SX___arcsinh (castSXMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___arccosh" c_CasADi__Matrix_CasADi__SX___arccosh+ :: Ptr SXMatrix' -> IO (Ptr SXMatrix')+casADi__Matrix_CasADi__SX___arccosh+ :: SXMatrix -> IO SXMatrix+casADi__Matrix_CasADi__SX___arccosh x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_CasADi__SX___arccosh x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++-- classy wrapper+{-|+>Operations defined in the standard namespace for unambigous access and Numpy+>compatibility.+-}+sxMatrix_arccosh :: SXMatrixClass a => a -> IO SXMatrix+sxMatrix_arccosh x = casADi__Matrix_CasADi__SX___arccosh (castSXMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___arctanh" c_CasADi__Matrix_CasADi__SX___arctanh+ :: Ptr SXMatrix' -> IO (Ptr SXMatrix')+casADi__Matrix_CasADi__SX___arctanh+ :: SXMatrix -> IO SXMatrix+casADi__Matrix_CasADi__SX___arctanh x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_CasADi__SX___arctanh x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++-- classy wrapper+{-|+>Operations defined in the standard namespace for unambigous access and Numpy+>compatibility.+-}+sxMatrix_arctanh :: SXMatrixClass a => a -> IO SXMatrix+sxMatrix_arctanh x = casADi__Matrix_CasADi__SX___arctanh (castSXMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___arctan2" c_CasADi__Matrix_CasADi__SX___arctan2+ :: Ptr SXMatrix' -> Ptr SXMatrix' -> IO (Ptr SXMatrix')+casADi__Matrix_CasADi__SX___arctan2+ :: SXMatrix -> SXMatrix -> IO SXMatrix+casADi__Matrix_CasADi__SX___arctan2 x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__Matrix_CasADi__SX___arctan2 x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++-- classy wrapper+{-|+>Operations defined in the standard namespace for unambigous access and Numpy+>compatibility.+-}+sxMatrix_arctan2 :: SXMatrixClass a => a -> SXMatrix -> IO SXMatrix+sxMatrix_arctan2 x = casADi__Matrix_CasADi__SX___arctan2 (castSXMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___log10" c_CasADi__Matrix_CasADi__SX___log10+ :: Ptr SXMatrix' -> IO (Ptr SXMatrix')+casADi__Matrix_CasADi__SX___log10+ :: SXMatrix -> IO SXMatrix+casADi__Matrix_CasADi__SX___log10 x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_CasADi__SX___log10 x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++-- classy wrapper+{-|+>Operations defined in the standard namespace for unambigous access and Numpy+>compatibility.+-}+sxMatrix_log10 :: SXMatrixClass a => a -> IO SXMatrix+sxMatrix_log10 x = casADi__Matrix_CasADi__SX___log10 (castSXMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___printme" c_CasADi__Matrix_CasADi__SX___printme+ :: Ptr SXMatrix' -> Ptr SXMatrix' -> IO (Ptr SXMatrix')+casADi__Matrix_CasADi__SX___printme+ :: SXMatrix -> SXMatrix -> IO SXMatrix+casADi__Matrix_CasADi__SX___printme x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__Matrix_CasADi__SX___printme x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++-- classy wrapper+{-|+>Operations defined in the standard namespace for unambigous access and Numpy+>compatibility.+-}+sxMatrix_printme :: SXMatrixClass a => a -> SXMatrix -> IO SXMatrix+sxMatrix_printme x = casADi__Matrix_CasADi__SX___printme (castSXMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___logic_not" c_CasADi__Matrix_CasADi__SX___logic_not+ :: Ptr SXMatrix' -> IO (Ptr SXMatrix')+casADi__Matrix_CasADi__SX___logic_not+ :: SXMatrix -> IO SXMatrix+casADi__Matrix_CasADi__SX___logic_not x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_CasADi__SX___logic_not x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++-- classy wrapper+{-|+>Operations defined in the standard namespace for unambigous access and Numpy+>compatibility.+-}+sxMatrix_logic_not :: SXMatrixClass a => a -> IO SXMatrix+sxMatrix_logic_not x = casADi__Matrix_CasADi__SX___logic_not (castSXMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___logic_and" c_CasADi__Matrix_CasADi__SX___logic_and+ :: Ptr SXMatrix' -> Ptr SXMatrix' -> IO (Ptr SXMatrix')+casADi__Matrix_CasADi__SX___logic_and+ :: SXMatrix -> SXMatrix -> IO SXMatrix+casADi__Matrix_CasADi__SX___logic_and x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__Matrix_CasADi__SX___logic_and x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++-- classy wrapper+{-|+>Operations defined in the standard namespace for unambigous access and Numpy+>compatibility.+-}+sxMatrix_logic_and :: SXMatrixClass a => a -> SXMatrix -> IO SXMatrix+sxMatrix_logic_and x = casADi__Matrix_CasADi__SX___logic_and (castSXMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___logic_or" c_CasADi__Matrix_CasADi__SX___logic_or+ :: Ptr SXMatrix' -> Ptr SXMatrix' -> IO (Ptr SXMatrix')+casADi__Matrix_CasADi__SX___logic_or+ :: SXMatrix -> SXMatrix -> IO SXMatrix+casADi__Matrix_CasADi__SX___logic_or x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__Matrix_CasADi__SX___logic_or x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++-- classy wrapper+{-|+>Operations defined in the standard namespace for unambigous access and Numpy+>compatibility.+-}+sxMatrix_logic_or :: SXMatrixClass a => a -> SXMatrix -> IO SXMatrix+sxMatrix_logic_or x = casADi__Matrix_CasADi__SX___logic_or (castSXMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___if_else_zero" c_CasADi__Matrix_CasADi__SX___if_else_zero+ :: Ptr SXMatrix' -> Ptr SXMatrix' -> IO (Ptr SXMatrix')+casADi__Matrix_CasADi__SX___if_else_zero+ :: SXMatrix -> SXMatrix -> IO SXMatrix+casADi__Matrix_CasADi__SX___if_else_zero x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__Matrix_CasADi__SX___if_else_zero x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++-- classy wrapper+{-|+>Operations defined in the standard namespace for unambigous access and Numpy+>compatibility.+-}+sxMatrix_if_else_zero :: SXMatrixClass a => a -> SXMatrix -> IO SXMatrix+sxMatrix_if_else_zero x = casADi__Matrix_CasADi__SX___if_else_zero (castSXMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___className" c_CasADi__Matrix_CasADi__SX___className+ :: IO (Ptr StdString')+casADi__Matrix_CasADi__SX___className+ :: IO String+casADi__Matrix_CasADi__SX___className =+ c_CasADi__Matrix_CasADi__SX___className >>= (newForeignPtr c_delete_std__string) >>= wrapReturn++-- classy wrapper+{-|+>Printing.+-}+sxMatrix_className :: IO String+sxMatrix_className = casADi__Matrix_CasADi__SX___className+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___printScalar_TIC" c_CasADi__Matrix_CasADi__SX___printScalar_TIC+ :: Ptr SXMatrix' -> IO ()+casADi__Matrix_CasADi__SX___printScalar'+ :: SXMatrix -> IO ()+casADi__Matrix_CasADi__SX___printScalar' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_CasADi__SX___printScalar_TIC x0' >>= wrapReturn++-- classy wrapper+sxMatrix_printScalar' :: SXMatrixClass a => a -> IO ()+sxMatrix_printScalar' x = casADi__Matrix_CasADi__SX___printScalar' (castSXMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___printVector_TIC" c_CasADi__Matrix_CasADi__SX___printVector_TIC+ :: Ptr SXMatrix' -> IO ()+casADi__Matrix_CasADi__SX___printVector'+ :: SXMatrix -> IO ()+casADi__Matrix_CasADi__SX___printVector' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_CasADi__SX___printVector_TIC x0' >>= wrapReturn++-- classy wrapper+sxMatrix_printVector' :: SXMatrixClass a => a -> IO ()+sxMatrix_printVector' x = casADi__Matrix_CasADi__SX___printVector' (castSXMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___printMatrix_TIC" c_CasADi__Matrix_CasADi__SX___printMatrix_TIC+ :: Ptr SXMatrix' -> IO ()+casADi__Matrix_CasADi__SX___printMatrix'+ :: SXMatrix -> IO ()+casADi__Matrix_CasADi__SX___printMatrix' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_CasADi__SX___printMatrix_TIC x0' >>= wrapReturn++-- classy wrapper+sxMatrix_printMatrix' :: SXMatrixClass a => a -> IO ()+sxMatrix_printMatrix' x = casADi__Matrix_CasADi__SX___printMatrix' (castSXMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___printSparse_TIC" c_CasADi__Matrix_CasADi__SX___printSparse_TIC+ :: Ptr SXMatrix' -> IO ()+casADi__Matrix_CasADi__SX___printSparse'+ :: SXMatrix -> IO ()+casADi__Matrix_CasADi__SX___printSparse' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_CasADi__SX___printSparse_TIC x0' >>= wrapReturn++-- classy wrapper+sxMatrix_printSparse' :: SXMatrixClass a => a -> IO ()+sxMatrix_printSparse' x = casADi__Matrix_CasADi__SX___printSparse' (castSXMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___printDense_TIC" c_CasADi__Matrix_CasADi__SX___printDense_TIC+ :: Ptr SXMatrix' -> IO ()+casADi__Matrix_CasADi__SX___printDense'+ :: SXMatrix -> IO ()+casADi__Matrix_CasADi__SX___printDense' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_CasADi__SX___printDense_TIC x0' >>= wrapReturn++-- classy wrapper+sxMatrix_printDense' :: SXMatrixClass a => a -> IO ()+sxMatrix_printDense' x = casADi__Matrix_CasADi__SX___printDense' (castSXMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___col" c_CasADi__Matrix_CasADi__SX___col+ :: Ptr SXMatrix' -> CInt -> IO CInt+casADi__Matrix_CasADi__SX___col+ :: SXMatrix -> Int -> IO Int+casADi__Matrix_CasADi__SX___col x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__Matrix_CasADi__SX___col x0' x1' >>= wrapReturn++-- classy wrapper+sxMatrix_col :: SXMatrixClass a => a -> Int -> IO Int+sxMatrix_col x = casADi__Matrix_CasADi__SX___col (castSXMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___rowind" c_CasADi__Matrix_CasADi__SX___rowind+ :: Ptr SXMatrix' -> CInt -> IO CInt+casADi__Matrix_CasADi__SX___rowind+ :: SXMatrix -> Int -> IO Int+casADi__Matrix_CasADi__SX___rowind x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__Matrix_CasADi__SX___rowind x0' x1' >>= wrapReturn++-- classy wrapper+sxMatrix_rowind :: SXMatrixClass a => a -> Int -> IO Int+sxMatrix_rowind x = casADi__Matrix_CasADi__SX___rowind (castSXMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___clear" c_CasADi__Matrix_CasADi__SX___clear+ :: Ptr SXMatrix' -> IO ()+casADi__Matrix_CasADi__SX___clear+ :: SXMatrix -> IO ()+casADi__Matrix_CasADi__SX___clear x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_CasADi__SX___clear x0' >>= wrapReturn++-- classy wrapper+sxMatrix_clear :: SXMatrixClass a => a -> IO ()+sxMatrix_clear x = casADi__Matrix_CasADi__SX___clear (castSXMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___resize" c_CasADi__Matrix_CasADi__SX___resize+ :: Ptr SXMatrix' -> CInt -> CInt -> IO ()+casADi__Matrix_CasADi__SX___resize+ :: SXMatrix -> Int -> Int -> IO ()+casADi__Matrix_CasADi__SX___resize x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__Matrix_CasADi__SX___resize x0' x1' x2' >>= wrapReturn++-- classy wrapper+sxMatrix_resize :: SXMatrixClass a => a -> Int -> Int -> IO ()+sxMatrix_resize x = casADi__Matrix_CasADi__SX___resize (castSXMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___reserve" c_CasADi__Matrix_CasADi__SX___reserve+ :: Ptr SXMatrix' -> CInt -> IO ()+casADi__Matrix_CasADi__SX___reserve+ :: SXMatrix -> Int -> IO ()+casADi__Matrix_CasADi__SX___reserve x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__Matrix_CasADi__SX___reserve x0' x1' >>= wrapReturn++-- classy wrapper+sxMatrix_reserve :: SXMatrixClass a => a -> Int -> IO ()+sxMatrix_reserve x = casADi__Matrix_CasADi__SX___reserve (castSXMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___reserve_TIC" c_CasADi__Matrix_CasADi__SX___reserve_TIC+ :: Ptr SXMatrix' -> CInt -> CInt -> IO ()+casADi__Matrix_CasADi__SX___reserve'+ :: SXMatrix -> Int -> Int -> IO ()+casADi__Matrix_CasADi__SX___reserve' x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__Matrix_CasADi__SX___reserve_TIC x0' x1' x2' >>= wrapReturn++-- classy wrapper+sxMatrix_reserve' :: SXMatrixClass a => a -> Int -> Int -> IO ()+sxMatrix_reserve' x = casADi__Matrix_CasADi__SX___reserve' (castSXMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___erase" c_CasADi__Matrix_CasADi__SX___erase+ :: Ptr SXMatrix' -> Ptr (CppVec CInt) -> Ptr (CppVec CInt) -> IO ()+casADi__Matrix_CasADi__SX___erase+ :: SXMatrix -> Vector Int -> Vector Int -> IO ()+casADi__Matrix_CasADi__SX___erase x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__Matrix_CasADi__SX___erase x0' x1' x2' >>= wrapReturn++-- classy wrapper+{-|+>Erase a submatrix Erase rows and/or columns of a matrix.+-}+sxMatrix_erase :: SXMatrixClass a => a -> Vector Int -> Vector Int -> IO ()+sxMatrix_erase x = casADi__Matrix_CasADi__SX___erase (castSXMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___remove" c_CasADi__Matrix_CasADi__SX___remove+ :: Ptr SXMatrix' -> Ptr (CppVec CInt) -> Ptr (CppVec CInt) -> IO ()+casADi__Matrix_CasADi__SX___remove+ :: SXMatrix -> Vector Int -> Vector Int -> IO ()+casADi__Matrix_CasADi__SX___remove x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__Matrix_CasADi__SX___remove x0' x1' x2' >>= wrapReturn++-- classy wrapper+{-|+>Remove rows or columns Rremove/delete rows and/or columns of a matrix.+-}+sxMatrix_remove :: SXMatrixClass a => a -> Vector Int -> Vector Int -> IO ()+sxMatrix_remove x = casADi__Matrix_CasADi__SX___remove (castSXMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___enlarge" c_CasADi__Matrix_CasADi__SX___enlarge+ :: Ptr SXMatrix' -> CInt -> CInt -> Ptr (CppVec CInt) -> Ptr (CppVec CInt) -> IO ()+casADi__Matrix_CasADi__SX___enlarge+ :: SXMatrix -> Int -> Int -> Vector Int -> Vector Int -> IO ()+casADi__Matrix_CasADi__SX___enlarge x0 x1 x2 x3 x4 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ withMarshal x3 $ \x3' ->+ withMarshal x4 $ \x4' ->+ c_CasADi__Matrix_CasADi__SX___enlarge x0' x1' x2' x3' x4' >>= wrapReturn++-- classy wrapper+{-|+>Enlarge matrix Make the matrix larger by inserting empty rows and columns,+>keeping the existing non-zeros.+-}+sxMatrix_enlarge :: SXMatrixClass a => a -> Int -> Int -> Vector Int -> Vector Int -> IO ()+sxMatrix_enlarge x = casADi__Matrix_CasADi__SX___enlarge (castSXMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___data" c_CasADi__Matrix_CasADi__SX___data+ :: Ptr SXMatrix' -> IO (Ptr (CppVec (Ptr SX')))+casADi__Matrix_CasADi__SX___data+ :: SXMatrix -> IO (Vector SX)+casADi__Matrix_CasADi__SX___data x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_CasADi__SX___data x0' >>= (newForeignPtr c_delete_std__vector_CasADi__SX_) >>= wrapReturn++-- classy wrapper+{-|+>> std::vector< T > & CasADi::Matrix< T >::data()+>------------------------------------------------------------------------+>+>Access the non-zero elements.+>+>> const std::vector< T > & CasADi::Matrix< T >::data() const +>------------------------------------------------------------------------+>+>Const access the non-zero elements.+-}+sxMatrix_data :: SXMatrixClass a => a -> IO (Vector SX)+sxMatrix_data x = casADi__Matrix_CasADi__SX___data (castSXMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___sparsityRef" c_CasADi__Matrix_CasADi__SX___sparsityRef+ :: Ptr SXMatrix' -> IO (Ptr CRSSparsity')+casADi__Matrix_CasADi__SX___sparsityRef+ :: SXMatrix -> IO CRSSparsity+casADi__Matrix_CasADi__SX___sparsityRef x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_CasADi__SX___sparsityRef x0' >>= (newForeignPtr c_delete_CasADi__CRSSparsity) >>= wrapReturn++-- classy wrapper+{-|+>Access the sparsity, make a copy if there are multiple references to it.+-}+sxMatrix_sparsityRef :: SXMatrixClass a => a -> IO CRSSparsity+sxMatrix_sparsityRef x = casADi__Matrix_CasADi__SX___sparsityRef (castSXMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___set" c_CasADi__Matrix_CasADi__SX___set+ :: Ptr SXMatrix' -> Ptr SX' -> CInt -> IO ()+casADi__Matrix_CasADi__SX___set+ :: SXMatrix -> SX -> Sparsity -> IO ()+casADi__Matrix_CasADi__SX___set x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__Matrix_CasADi__SX___set x0' x1' x2' >>= wrapReturn++-- classy wrapper+{-|+>> void CasADi::Matrix< T >::set(T val, Sparsity sp=SPARSE)+>------------------------------------------------------------------------+>+>Set the non-zero elements, scalar.+>+>> void CasADi::Matrix< T >::set(const std::vector< T > &val, Sparsity sp=SPARSE)+>------------------------------------------------------------------------+>+>Set the non-zero elements, vector.+>+>> void CasADi::Matrix< T >::set(const Matrix< T > &val, Sparsity sp=SPARSE)+>------------------------------------------------------------------------+>+>Set the non-zero elements, Matrix.+>+>> void CasADi::Matrix< T >::set(const T *val, Sparsity sp=SPARSE)+>------------------------------------------------------------------------+>+>Legacy - use setArray instead.+-}+sxMatrix_set :: SXMatrixClass a => a -> SX -> Sparsity -> IO ()+sxMatrix_set x = casADi__Matrix_CasADi__SX___set (castSXMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___set_TIC" c_CasADi__Matrix_CasADi__SX___set_TIC+ :: Ptr SXMatrix' -> Ptr SX' -> IO ()+casADi__Matrix_CasADi__SX___set'+ :: SXMatrix -> SX -> IO ()+casADi__Matrix_CasADi__SX___set' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__Matrix_CasADi__SX___set_TIC x0' x1' >>= wrapReturn++-- classy wrapper+sxMatrix_set' :: SXMatrixClass a => a -> SX -> IO ()+sxMatrix_set' x = casADi__Matrix_CasADi__SX___set' (castSXMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___get" c_CasADi__Matrix_CasADi__SX___get+ :: Ptr SXMatrix' -> Ptr SX' -> CInt -> IO ()+casADi__Matrix_CasADi__SX___get+ :: SXMatrix -> SX -> Sparsity -> IO ()+casADi__Matrix_CasADi__SX___get x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__Matrix_CasADi__SX___get x0' x1' x2' >>= wrapReturn++-- classy wrapper+{-|+>> void CasADi::Matrix< T >::get(T &val, Sparsity sp=SPARSE) const +>------------------------------------------------------------------------+>+>Get the non-zero elements, scalar.+>+>> void CasADi::Matrix< T >::get(std::vector< T > &val, Sparsity sp=SPARSE) const +>------------------------------------------------------------------------+>+>Get the non-zero elements, vector.+>+>> void CasADi::Matrix< T >::get(Matrix< T > &val, Sparsity sp=SPARSE) const +>------------------------------------------------------------------------+>+>Get the non-zero elements, Matrix.+>+>> void CasADi::Matrix< T >::get(T *val, Sparsity sp=SPARSE) const +>------------------------------------------------------------------------+>+>Legacy - use getArray instead.+-}+sxMatrix_get :: SXMatrixClass a => a -> SX -> Sparsity -> IO ()+sxMatrix_get x = casADi__Matrix_CasADi__SX___get (castSXMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___get_TIC" c_CasADi__Matrix_CasADi__SX___get_TIC+ :: Ptr SXMatrix' -> Ptr SX' -> IO ()+casADi__Matrix_CasADi__SX___get'+ :: SXMatrix -> SX -> IO ()+casADi__Matrix_CasADi__SX___get' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__Matrix_CasADi__SX___get_TIC x0' x1' >>= wrapReturn++-- classy wrapper+sxMatrix_get' :: SXMatrixClass a => a -> SX -> IO ()+sxMatrix_get' x = casADi__Matrix_CasADi__SX___get' (castSXMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___set_TIC_TIC" c_CasADi__Matrix_CasADi__SX___set_TIC_TIC+ :: Ptr SXMatrix' -> Ptr (CppVec (Ptr SX')) -> CInt -> IO ()+casADi__Matrix_CasADi__SX___set''+ :: SXMatrix -> Vector SX -> Sparsity -> IO ()+casADi__Matrix_CasADi__SX___set'' x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__Matrix_CasADi__SX___set_TIC_TIC x0' x1' x2' >>= wrapReturn++-- classy wrapper+sxMatrix_set'' :: SXMatrixClass a => a -> Vector SX -> Sparsity -> IO ()+sxMatrix_set'' x = casADi__Matrix_CasADi__SX___set'' (castSXMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___set_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SX___set_TIC_TIC_TIC+ :: Ptr SXMatrix' -> Ptr (CppVec (Ptr SX')) -> IO ()+casADi__Matrix_CasADi__SX___set'''+ :: SXMatrix -> Vector SX -> IO ()+casADi__Matrix_CasADi__SX___set''' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__Matrix_CasADi__SX___set_TIC_TIC_TIC x0' x1' >>= wrapReturn++-- classy wrapper+sxMatrix_set''' :: SXMatrixClass a => a -> Vector SX -> IO ()+sxMatrix_set''' x = casADi__Matrix_CasADi__SX___set''' (castSXMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___get_TIC_TIC" c_CasADi__Matrix_CasADi__SX___get_TIC_TIC+ :: Ptr SXMatrix' -> Ptr (CppVec (Ptr SX')) -> CInt -> IO ()+casADi__Matrix_CasADi__SX___get''+ :: SXMatrix -> Vector SX -> Sparsity -> IO ()+casADi__Matrix_CasADi__SX___get'' x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__Matrix_CasADi__SX___get_TIC_TIC x0' x1' x2' >>= wrapReturn++-- classy wrapper+sxMatrix_get'' :: SXMatrixClass a => a -> Vector SX -> Sparsity -> IO ()+sxMatrix_get'' x = casADi__Matrix_CasADi__SX___get'' (castSXMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___get_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SX___get_TIC_TIC_TIC+ :: Ptr SXMatrix' -> Ptr (CppVec (Ptr SX')) -> IO ()+casADi__Matrix_CasADi__SX___get'''+ :: SXMatrix -> Vector SX -> IO ()+casADi__Matrix_CasADi__SX___get''' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__Matrix_CasADi__SX___get_TIC_TIC_TIC x0' x1' >>= wrapReturn++-- classy wrapper+sxMatrix_get''' :: SXMatrixClass a => a -> Vector SX -> IO ()+sxMatrix_get''' x = casADi__Matrix_CasADi__SX___get''' (castSXMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___set_TIC_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SX___set_TIC_TIC_TIC_TIC+ :: Ptr SXMatrix' -> Ptr SXMatrix' -> CInt -> IO ()+casADi__Matrix_CasADi__SX___set''''+ :: SXMatrix -> SXMatrix -> Sparsity -> IO ()+casADi__Matrix_CasADi__SX___set'''' x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__Matrix_CasADi__SX___set_TIC_TIC_TIC_TIC x0' x1' x2' >>= wrapReturn++-- classy wrapper+sxMatrix_set'''' :: SXMatrixClass a => a -> SXMatrix -> Sparsity -> IO ()+sxMatrix_set'''' x = casADi__Matrix_CasADi__SX___set'''' (castSXMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___set_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SX___set_TIC_TIC_TIC_TIC_TIC+ :: Ptr SXMatrix' -> Ptr SXMatrix' -> IO ()+casADi__Matrix_CasADi__SX___set'''''+ :: SXMatrix -> SXMatrix -> IO ()+casADi__Matrix_CasADi__SX___set''''' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__Matrix_CasADi__SX___set_TIC_TIC_TIC_TIC_TIC x0' x1' >>= wrapReturn++-- classy wrapper+sxMatrix_set''''' :: SXMatrixClass a => a -> SXMatrix -> IO ()+sxMatrix_set''''' x = casADi__Matrix_CasADi__SX___set''''' (castSXMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___get_TIC_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SX___get_TIC_TIC_TIC_TIC+ :: Ptr SXMatrix' -> Ptr SXMatrix' -> CInt -> IO ()+casADi__Matrix_CasADi__SX___get''''+ :: SXMatrix -> SXMatrix -> Sparsity -> IO ()+casADi__Matrix_CasADi__SX___get'''' x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__Matrix_CasADi__SX___get_TIC_TIC_TIC_TIC x0' x1' x2' >>= wrapReturn++-- classy wrapper+sxMatrix_get'''' :: SXMatrixClass a => a -> SXMatrix -> Sparsity -> IO ()+sxMatrix_get'''' x = casADi__Matrix_CasADi__SX___get'''' (castSXMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___get_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SX___get_TIC_TIC_TIC_TIC_TIC+ :: Ptr SXMatrix' -> Ptr SXMatrix' -> IO ()+casADi__Matrix_CasADi__SX___get'''''+ :: SXMatrix -> SXMatrix -> IO ()+casADi__Matrix_CasADi__SX___get''''' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__Matrix_CasADi__SX___get_TIC_TIC_TIC_TIC_TIC x0' x1' >>= wrapReturn++-- classy wrapper+sxMatrix_get''''' :: SXMatrixClass a => a -> SXMatrix -> IO ()+sxMatrix_get''''' x = casADi__Matrix_CasADi__SX___get''''' (castSXMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___sparse" c_CasADi__Matrix_CasADi__SX___sparse+ :: CInt -> CInt -> IO (Ptr SXMatrix')+casADi__Matrix_CasADi__SX___sparse+ :: Int -> Int -> IO SXMatrix+casADi__Matrix_CasADi__SX___sparse x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__Matrix_CasADi__SX___sparse x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++-- classy wrapper+{-|+>> Matrix< T > CasADi::Matrix< T >::sparse(int nrow, int ncol=1)+>+>> Matrix< T > CasADi::Matrix< T >::sparse(const std::pair< int, int > &nm)+>------------------------------------------------------------------------+>+>create a sparse matrix with all zeros+>+>> Matrix< T > CasADi::Matrix< T >::sparse(const std::vector< int > &row, const std::vector< int > &col, const std::vector< T > &d, int n, int m)+>+>> Matrix< T > CasADi::Matrix< T >::sparse(const std::vector< int > &row, const std::vector< int > &col, const std::vector< T > &d, const std::pair< int, int > &nm)+>------------------------------------------------------------------------+>+>Construct a sparse matrix from triplet form.+-}+sxMatrix_sparse :: Int -> Int -> IO SXMatrix+sxMatrix_sparse = casADi__Matrix_CasADi__SX___sparse+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___sparse_TIC" c_CasADi__Matrix_CasADi__SX___sparse_TIC+ :: CInt -> IO (Ptr SXMatrix')+casADi__Matrix_CasADi__SX___sparse'+ :: Int -> IO SXMatrix+casADi__Matrix_CasADi__SX___sparse' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_CasADi__SX___sparse_TIC x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++-- classy wrapper+sxMatrix_sparse' :: Int -> IO SXMatrix+sxMatrix_sparse' = casADi__Matrix_CasADi__SX___sparse'+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___sparse_TIC_TIC" c_CasADi__Matrix_CasADi__SX___sparse_TIC_TIC+ :: Ptr (CppVec CInt) -> Ptr (CppVec CInt) -> Ptr (CppVec (Ptr SX')) -> IO (Ptr SXMatrix')+casADi__Matrix_CasADi__SX___sparse''+ :: Vector Int -> Vector Int -> Vector SX -> IO SXMatrix+casADi__Matrix_CasADi__SX___sparse'' x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__Matrix_CasADi__SX___sparse_TIC_TIC x0' x1' x2' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++-- classy wrapper+sxMatrix_sparse'' :: Vector Int -> Vector Int -> Vector SX -> IO SXMatrix+sxMatrix_sparse'' = casADi__Matrix_CasADi__SX___sparse''+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___sparse_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SX___sparse_TIC_TIC_TIC+ :: Ptr (CppVec CInt) -> Ptr (CppVec CInt) -> Ptr (CppVec (Ptr SX')) -> CInt -> CInt -> IO (Ptr SXMatrix')+casADi__Matrix_CasADi__SX___sparse'''+ :: Vector Int -> Vector Int -> Vector SX -> Int -> Int -> IO SXMatrix+casADi__Matrix_CasADi__SX___sparse''' x0 x1 x2 x3 x4 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ withMarshal x3 $ \x3' ->+ withMarshal x4 $ \x4' ->+ c_CasADi__Matrix_CasADi__SX___sparse_TIC_TIC_TIC x0' x1' x2' x3' x4' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++-- classy wrapper+sxMatrix_sparse''' :: Vector Int -> Vector Int -> Vector SX -> Int -> Int -> IO SXMatrix+sxMatrix_sparse''' = casADi__Matrix_CasADi__SX___sparse'''+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___zeros" c_CasADi__Matrix_CasADi__SX___zeros+ :: Ptr CRSSparsity' -> IO (Ptr SXMatrix')+casADi__Matrix_CasADi__SX___zeros+ :: CRSSparsity -> IO SXMatrix+casADi__Matrix_CasADi__SX___zeros x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_CasADi__SX___zeros x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++-- classy wrapper+{-|+>create a dense matrix with all zeros+-}+sxMatrix_zeros :: CRSSparsity -> IO SXMatrix+sxMatrix_zeros = casADi__Matrix_CasADi__SX___zeros+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___zeros_TIC" c_CasADi__Matrix_CasADi__SX___zeros_TIC+ :: CInt -> CInt -> IO (Ptr SXMatrix')+casADi__Matrix_CasADi__SX___zeros'+ :: Int -> Int -> IO SXMatrix+casADi__Matrix_CasADi__SX___zeros' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__Matrix_CasADi__SX___zeros_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++-- classy wrapper+sxMatrix_zeros' :: Int -> Int -> IO SXMatrix+sxMatrix_zeros' = casADi__Matrix_CasADi__SX___zeros'+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___zeros_TIC_TIC" c_CasADi__Matrix_CasADi__SX___zeros_TIC_TIC+ :: CInt -> IO (Ptr SXMatrix')+casADi__Matrix_CasADi__SX___zeros''+ :: Int -> IO SXMatrix+casADi__Matrix_CasADi__SX___zeros'' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_CasADi__SX___zeros_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++-- classy wrapper+sxMatrix_zeros'' :: Int -> IO SXMatrix+sxMatrix_zeros'' = casADi__Matrix_CasADi__SX___zeros''+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___ones" c_CasADi__Matrix_CasADi__SX___ones+ :: Ptr CRSSparsity' -> IO (Ptr SXMatrix')+casADi__Matrix_CasADi__SX___ones+ :: CRSSparsity -> IO SXMatrix+casADi__Matrix_CasADi__SX___ones x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_CasADi__SX___ones x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++-- classy wrapper+{-|+>create a matrix with all ones+-}+sxMatrix_ones :: CRSSparsity -> IO SXMatrix+sxMatrix_ones = casADi__Matrix_CasADi__SX___ones+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___ones_TIC" c_CasADi__Matrix_CasADi__SX___ones_TIC+ :: CInt -> CInt -> IO (Ptr SXMatrix')+casADi__Matrix_CasADi__SX___ones'+ :: Int -> Int -> IO SXMatrix+casADi__Matrix_CasADi__SX___ones' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__Matrix_CasADi__SX___ones_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++-- classy wrapper+sxMatrix_ones' :: Int -> Int -> IO SXMatrix+sxMatrix_ones' = casADi__Matrix_CasADi__SX___ones'+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___ones_TIC_TIC" c_CasADi__Matrix_CasADi__SX___ones_TIC_TIC+ :: CInt -> IO (Ptr SXMatrix')+casADi__Matrix_CasADi__SX___ones''+ :: Int -> IO SXMatrix+casADi__Matrix_CasADi__SX___ones'' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_CasADi__SX___ones_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++-- classy wrapper+sxMatrix_ones'' :: Int -> IO SXMatrix+sxMatrix_ones'' = casADi__Matrix_CasADi__SX___ones''+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___inf" c_CasADi__Matrix_CasADi__SX___inf+ :: Ptr CRSSparsity' -> IO (Ptr SXMatrix')+casADi__Matrix_CasADi__SX___inf+ :: CRSSparsity -> IO SXMatrix+casADi__Matrix_CasADi__SX___inf x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_CasADi__SX___inf x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++-- classy wrapper+{-|+>create a matrix with all inf+-}+sxMatrix_inf :: CRSSparsity -> IO SXMatrix+sxMatrix_inf = casADi__Matrix_CasADi__SX___inf+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___inf_TIC" c_CasADi__Matrix_CasADi__SX___inf_TIC+ :: CInt -> CInt -> IO (Ptr SXMatrix')+casADi__Matrix_CasADi__SX___inf'+ :: Int -> Int -> IO SXMatrix+casADi__Matrix_CasADi__SX___inf' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__Matrix_CasADi__SX___inf_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++-- classy wrapper+sxMatrix_inf' :: Int -> Int -> IO SXMatrix+sxMatrix_inf' = casADi__Matrix_CasADi__SX___inf'+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___inf_TIC_TIC" c_CasADi__Matrix_CasADi__SX___inf_TIC_TIC+ :: CInt -> IO (Ptr SXMatrix')+casADi__Matrix_CasADi__SX___inf''+ :: Int -> IO SXMatrix+casADi__Matrix_CasADi__SX___inf'' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_CasADi__SX___inf_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++-- classy wrapper+sxMatrix_inf'' :: Int -> IO SXMatrix+sxMatrix_inf'' = casADi__Matrix_CasADi__SX___inf''+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___inf_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SX___inf_TIC_TIC_TIC+ :: IO (Ptr SXMatrix')+casADi__Matrix_CasADi__SX___inf'''+ :: IO SXMatrix+casADi__Matrix_CasADi__SX___inf''' =+ c_CasADi__Matrix_CasADi__SX___inf_TIC_TIC_TIC >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++-- classy wrapper+sxMatrix_inf''' :: IO SXMatrix+sxMatrix_inf''' = casADi__Matrix_CasADi__SX___inf'''+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___nan" c_CasADi__Matrix_CasADi__SX___nan+ :: Ptr CRSSparsity' -> IO (Ptr SXMatrix')+casADi__Matrix_CasADi__SX___nan+ :: CRSSparsity -> IO SXMatrix+casADi__Matrix_CasADi__SX___nan x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_CasADi__SX___nan x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++-- classy wrapper+{-|+>create a matrix with all nan+-}+sxMatrix_nan :: CRSSparsity -> IO SXMatrix+sxMatrix_nan = casADi__Matrix_CasADi__SX___nan+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___nan_TIC" c_CasADi__Matrix_CasADi__SX___nan_TIC+ :: CInt -> CInt -> IO (Ptr SXMatrix')+casADi__Matrix_CasADi__SX___nan'+ :: Int -> Int -> IO SXMatrix+casADi__Matrix_CasADi__SX___nan' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__Matrix_CasADi__SX___nan_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++-- classy wrapper+sxMatrix_nan' :: Int -> Int -> IO SXMatrix+sxMatrix_nan' = casADi__Matrix_CasADi__SX___nan'+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___nan_TIC_TIC" c_CasADi__Matrix_CasADi__SX___nan_TIC_TIC+ :: CInt -> IO (Ptr SXMatrix')+casADi__Matrix_CasADi__SX___nan''+ :: Int -> IO SXMatrix+casADi__Matrix_CasADi__SX___nan'' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_CasADi__SX___nan_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++-- classy wrapper+sxMatrix_nan'' :: Int -> IO SXMatrix+sxMatrix_nan'' = casADi__Matrix_CasADi__SX___nan''+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___nan_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SX___nan_TIC_TIC_TIC+ :: IO (Ptr SXMatrix')+casADi__Matrix_CasADi__SX___nan'''+ :: IO SXMatrix+casADi__Matrix_CasADi__SX___nan''' =+ c_CasADi__Matrix_CasADi__SX___nan_TIC_TIC_TIC >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++-- classy wrapper+sxMatrix_nan''' :: IO SXMatrix+sxMatrix_nan''' = casADi__Matrix_CasADi__SX___nan'''+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___repmat" c_CasADi__Matrix_CasADi__SX___repmat+ :: Ptr SXMatrix' -> CInt -> CInt -> IO (Ptr SXMatrix')+casADi__Matrix_CasADi__SX___repmat+ :: SXMatrix -> Int -> Int -> IO SXMatrix+casADi__Matrix_CasADi__SX___repmat x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__Matrix_CasADi__SX___repmat x0' x1' x2' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++-- classy wrapper+{-|+>create a matrix by repeating an existing matrix+-}+sxMatrix_repmat :: SXMatrix -> Int -> Int -> IO SXMatrix+sxMatrix_repmat = casADi__Matrix_CasADi__SX___repmat+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___repmat_TIC" c_CasADi__Matrix_CasADi__SX___repmat_TIC+ :: Ptr SXMatrix' -> CInt -> IO (Ptr SXMatrix')+casADi__Matrix_CasADi__SX___repmat'+ :: SXMatrix -> Int -> IO SXMatrix+casADi__Matrix_CasADi__SX___repmat' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__Matrix_CasADi__SX___repmat_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++-- classy wrapper+sxMatrix_repmat' :: SXMatrix -> Int -> IO SXMatrix+sxMatrix_repmat' = casADi__Matrix_CasADi__SX___repmat'+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___eye" c_CasADi__Matrix_CasADi__SX___eye+ :: CInt -> IO (Ptr SXMatrix')+casADi__Matrix_CasADi__SX___eye+ :: Int -> IO SXMatrix+casADi__Matrix_CasADi__SX___eye x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_CasADi__SX___eye x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++-- classy wrapper+sxMatrix_eye :: Int -> IO SXMatrix+sxMatrix_eye = casADi__Matrix_CasADi__SX___eye+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___isNull" c_CasADi__Matrix_CasADi__SX___isNull+ :: Ptr SXMatrix' -> IO (Ptr CppBool')+casADi__Matrix_CasADi__SX___isNull+ :: SXMatrix -> IO Bool+casADi__Matrix_CasADi__SX___isNull x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_CasADi__SX___isNull x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++-- classy wrapper+{-|+>The following function is used to ensure similarity to MX, which is+>reference counted.+-}+sxMatrix_isNull :: SXMatrixClass a => a -> IO Bool+sxMatrix_isNull x = casADi__Matrix_CasADi__SX___isNull (castSXMatrix x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___setPrecision" c_CasADi__Matrix_CasADi__SX___setPrecision+ :: CInt -> IO ()+casADi__Matrix_CasADi__SX___setPrecision+ :: Int -> IO ()+casADi__Matrix_CasADi__SX___setPrecision x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_CasADi__SX___setPrecision x0' >>= wrapReturn++-- classy wrapper+{-|+>Set the 'precision, width & scientific' used in printing and serializing to+>streams.+-}+sxMatrix_setPrecision :: Int -> IO ()+sxMatrix_setPrecision = casADi__Matrix_CasADi__SX___setPrecision+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___setWidth" c_CasADi__Matrix_CasADi__SX___setWidth+ :: CInt -> IO ()+casADi__Matrix_CasADi__SX___setWidth+ :: Int -> IO ()+casADi__Matrix_CasADi__SX___setWidth x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_CasADi__SX___setWidth x0' >>= wrapReturn++-- classy wrapper+{-|+>Set the 'precision, width & scientific' used in printing and serializing to+>streams.+-}+sxMatrix_setWidth :: Int -> IO ()+sxMatrix_setWidth = casADi__Matrix_CasADi__SX___setWidth+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___setScientific" c_CasADi__Matrix_CasADi__SX___setScientific+ :: Ptr CppBool' -> IO ()+casADi__Matrix_CasADi__SX___setScientific+ :: Bool -> IO ()+casADi__Matrix_CasADi__SX___setScientific x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_CasADi__SX___setScientific x0' >>= wrapReturn++-- classy wrapper+{-|+>Set the 'precision, width & scientific' used in printing and serializing to+>streams.+-}+sxMatrix_setScientific :: Bool -> IO ()+sxMatrix_setScientific = casADi__Matrix_CasADi__SX___setScientific+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___SXMatrix" c_CasADi__Matrix_CasADi__SX___SXMatrix+ :: IO (Ptr SXMatrix')+casADi__Matrix_CasADi__SX___SXMatrix+ :: IO SXMatrix+casADi__Matrix_CasADi__SX___SXMatrix =+ c_CasADi__Matrix_CasADi__SX___SXMatrix >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++-- classy wrapper+{-|+>> CasADi::Matrix< T >::Matrix()+>------------------------------------------------------------------------+>+>constructors+>+>empty 0-by-0 matrix constructor+>+>> CasADi::Matrix< T >::Matrix(const Matrix< T > &m)+>------------------------------------------------------------------------+>+>Copy constructor.+>+>> CasADi::Matrix< T >::Matrix(int n, int m)+>------------------------------------------------------------------------+>+>empty n-by-m matrix constructor+>+>> CasADi::Matrix< T >::Matrix(int n, int m, const T &val)+>------------------------------------------------------------------------+>+>dense n-by-m matrix filled with val constructor+>+>> CasADi::Matrix< T >::Matrix(int n, int m, const std::vector< int > &col, const std::vector< int > &rowind, const std::vector< T > &d=std::vector< T >())+>------------------------------------------------------------------------+>+>sparse n-by-m matrix filled with given sparsity+>+>> CasADi::Matrix< T >::Matrix(const std::vector< std::vector< T > > &m)+>------------------------------------------------------------------------+>+>dense matrix constructor with data given as vector of vectors+>+>> CasADi::Matrix< T >::Matrix(const CRSSparsity &sparsity, const T &val=0)+>------------------------------------------------------------------------+>+>sparse matrix with a given sparsity+>+>> CasADi::Matrix< T >::Matrix(const CRSSparsity &sparsity, const std::vector< T > &d)+>------------------------------------------------------------------------+>+>sparse matrix with a given sparsity and non-zero elements.+>+>> CasADi::Matrix< T >::Matrix(double val)+>------------------------------------------------------------------------+>+>This constructor enables implicit type conversion from a numeric type.+>+>> CasADi::Matrix< T >::Matrix(const std::vector< T > &x)+>------------------------------------------------------------------------+>+>Construct from a vector.+>+>Thanks to implicit conversion, you can pretend that Matrix(const SX& x);+>exists. Note: above remark applies only to C++, not python or octave+>interfaces+>+>> CasADi::Matrix< T >::Matrix(const std::vector< T > &x, int n, int m)+>------------------------------------------------------------------------+>+>Construct dense matrix from a vector with the elements in column major+>ordering.+>+>> CasADi::Matrix< T >::Matrix(const Matrix< A > &x)+>------------------------------------------------------------------------+>+>Create a matrix from a matrix with a different type of matrix entries+>(assuming that the scalar conversion is valid)+>+>> CasADi::Matrix< T >::Matrix(const std::vector< A > &x)+>------------------------------------------------------------------------+>+>Create an expression from an stl vector.+>+>> CasADi::Matrix< T >::Matrix(const std::vector< A > &x, int n, int m)+>------------------------------------------------------------------------+>+>Create a non-vector expression from an stl vector.+-}+sxMatrix :: IO SXMatrix+sxMatrix = casADi__Matrix_CasADi__SX___SXMatrix+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___SXMatrix_TIC" c_CasADi__Matrix_CasADi__SX___SXMatrix_TIC+ :: Ptr SXMatrix' -> IO (Ptr SXMatrix')+casADi__Matrix_CasADi__SX___SXMatrix'+ :: SXMatrix -> IO SXMatrix+casADi__Matrix_CasADi__SX___SXMatrix' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_CasADi__SX___SXMatrix_TIC x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++-- classy wrapper+sxMatrix' :: SXMatrix -> IO SXMatrix+sxMatrix' = casADi__Matrix_CasADi__SX___SXMatrix'+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC" c_CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC+ :: CInt -> CInt -> IO (Ptr SXMatrix')+casADi__Matrix_CasADi__SX___SXMatrix''+ :: Int -> Int -> IO SXMatrix+casADi__Matrix_CasADi__SX___SXMatrix'' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++-- classy wrapper+sxMatrix'' :: Int -> Int -> IO SXMatrix+sxMatrix'' = casADi__Matrix_CasADi__SX___SXMatrix''+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC+ :: CInt -> CInt -> Ptr SX' -> IO (Ptr SXMatrix')+casADi__Matrix_CasADi__SX___SXMatrix'''+ :: Int -> Int -> SX -> IO SXMatrix+casADi__Matrix_CasADi__SX___SXMatrix''' x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC x0' x1' x2' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++-- classy wrapper+sxMatrix''' :: Int -> Int -> SX -> IO SXMatrix+sxMatrix''' = casADi__Matrix_CasADi__SX___SXMatrix'''+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC+ :: CInt -> CInt -> Ptr (CppVec CInt) -> Ptr (CppVec CInt) -> Ptr (CppVec (Ptr SX')) -> IO (Ptr SXMatrix')+casADi__Matrix_CasADi__SX___SXMatrix''''+ :: Int -> Int -> Vector Int -> Vector Int -> Vector SX -> IO SXMatrix+casADi__Matrix_CasADi__SX___SXMatrix'''' x0 x1 x2 x3 x4 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ withMarshal x3 $ \x3' ->+ withMarshal x4 $ \x4' ->+ c_CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC x0' x1' x2' x3' x4' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++-- classy wrapper+sxMatrix'''' :: Int -> Int -> Vector Int -> Vector Int -> Vector SX -> IO SXMatrix+sxMatrix'''' = casADi__Matrix_CasADi__SX___SXMatrix''''+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC+ :: CInt -> CInt -> Ptr (CppVec CInt) -> Ptr (CppVec CInt) -> IO (Ptr SXMatrix')+casADi__Matrix_CasADi__SX___SXMatrix'''''+ :: Int -> Int -> Vector Int -> Vector Int -> IO SXMatrix+casADi__Matrix_CasADi__SX___SXMatrix''''' x0 x1 x2 x3 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ withMarshal x3 $ \x3' ->+ c_CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC x0' x1' x2' x3' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++-- classy wrapper+sxMatrix''''' :: Int -> Int -> Vector Int -> Vector Int -> IO SXMatrix+sxMatrix''''' = casADi__Matrix_CasADi__SX___SXMatrix'''''+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC_TIC+ :: Ptr (CppVecVec (Ptr SX')) -> IO (Ptr SXMatrix')+casADi__Matrix_CasADi__SX___SXMatrix''''''+ :: Vector (Vector SX) -> IO SXMatrix+casADi__Matrix_CasADi__SX___SXMatrix'''''' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++-- classy wrapper+sxMatrix'''''' :: Vector (Vector SX) -> IO SXMatrix+sxMatrix'''''' = casADi__Matrix_CasADi__SX___SXMatrix''''''+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC+ :: Ptr CRSSparsity' -> Ptr SX' -> IO (Ptr SXMatrix')+casADi__Matrix_CasADi__SX___SXMatrix'''''''+ :: CRSSparsity -> SX -> IO SXMatrix+casADi__Matrix_CasADi__SX___SXMatrix''''''' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++-- classy wrapper+sxMatrix''''''' :: CRSSparsity -> SX -> IO SXMatrix+sxMatrix''''''' = casADi__Matrix_CasADi__SX___SXMatrix'''''''+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC+ :: Ptr CRSSparsity' -> IO (Ptr SXMatrix')+casADi__Matrix_CasADi__SX___SXMatrix''''''''+ :: CRSSparsity -> IO SXMatrix+casADi__Matrix_CasADi__SX___SXMatrix'''''''' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++-- classy wrapper+sxMatrix'''''''' :: CRSSparsity -> IO SXMatrix+sxMatrix'''''''' = casADi__Matrix_CasADi__SX___SXMatrix''''''''+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC+ :: Ptr CRSSparsity' -> Ptr (CppVec (Ptr SX')) -> IO (Ptr SXMatrix')+casADi__Matrix_CasADi__SX___SXMatrix'''''''''+ :: CRSSparsity -> Vector SX -> IO SXMatrix+casADi__Matrix_CasADi__SX___SXMatrix''''''''' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++-- classy wrapper+sxMatrix''''''''' :: CRSSparsity -> Vector SX -> IO SXMatrix+sxMatrix''''''''' = casADi__Matrix_CasADi__SX___SXMatrix'''''''''+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC+ :: CDouble -> IO (Ptr SXMatrix')+casADi__Matrix_CasADi__SX___SXMatrix''''''''''+ :: Double -> IO SXMatrix+casADi__Matrix_CasADi__SX___SXMatrix'''''''''' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++-- classy wrapper+sxMatrix'''''''''' :: Double -> IO SXMatrix+sxMatrix'''''''''' = casADi__Matrix_CasADi__SX___SXMatrix''''''''''+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC+ :: Ptr (CppVec (Ptr SX')) -> IO (Ptr SXMatrix')+casADi__Matrix_CasADi__SX___SXMatrix'''''''''''+ :: Vector SX -> IO SXMatrix+casADi__Matrix_CasADi__SX___SXMatrix''''''''''' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++-- classy wrapper+sxMatrix''''''''''' :: Vector SX -> IO SXMatrix+sxMatrix''''''''''' = casADi__Matrix_CasADi__SX___SXMatrix'''''''''''+++-- direct wrapper+foreign import ccall unsafe "CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC+ :: Ptr (CppVec (Ptr SX')) -> CInt -> CInt -> IO (Ptr SXMatrix')+casADi__Matrix_CasADi__SX___SXMatrix''''''''''''+ :: Vector SX -> Int -> Int -> IO SXMatrix+casADi__Matrix_CasADi__SX___SXMatrix'''''''''''' x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++-- classy wrapper+sxMatrix'''''''''''' :: Vector SX -> Int -> Int -> IO SXMatrix+sxMatrix'''''''''''' = casADi__Matrix_CasADi__SX___SXMatrix''''''''''''+
@@ -0,0 +1,156 @@+{-# OPTIONS_GHC -Wall #-}+{-# OPTIONS_GHC -fno-warn-unused-imports #-}+{-# OPTIONS_GHC -fno-warn-orphans #-}+{-# Language ForeignFunctionInterface #-}+{-# Language FlexibleInstances #-}+{-# Language MultiParamTypeClasses #-}++module Casadi.Wrappers.Classes.SharedObject+ (+ SharedObject,+ SharedObjectClass(..),+ sharedObject_assertInit,+ sharedObject_checkNode,+ sharedObject_init,+ sharedObject_isInit,+ sharedObject_makeUnique,+ sharedObject_makeUnique',+ sharedObject_printPtr',+ ) where+++import Prelude hiding ( Functor )++import Data.Vector ( Vector )+import Foreign.C.Types+import Foreign.Ptr ( Ptr )+import Foreign.ForeignPtr ( newForeignPtr )+import System.IO.Unsafe ( unsafePerformIO ) -- for show instances++import Casadi.Wrappers.Classes.PrintableObject+import Casadi.Wrappers.ForeignToolsInstances ( )+import Casadi.Wrappers.Deleters+import Casadi.Wrappers.Data+import Casadi.Wrappers.Enums+import Casadi.MarshalTypes ( CppVec, CppVecVec, CppVecVecVec,+ StdString', CppBool' ) -- StdOstream'+import Casadi.Marshal ( CornerCase(..), Marshal(..) )+import Casadi.WrapReturn ( WrapReturn(..) )++instance Show SharedObject where+ show = unsafePerformIO . printableObject_getDescription+-- direct wrapper+foreign import ccall unsafe "CasADi__SharedObject__printPtr_TIC" c_CasADi__SharedObject__printPtr_TIC+ :: Ptr SharedObject' -> IO ()+casADi__SharedObject__printPtr'+ :: SharedObject -> IO ()+casADi__SharedObject__printPtr' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__SharedObject__printPtr_TIC x0' >>= wrapReturn++-- classy wrapper+sharedObject_printPtr' :: SharedObjectClass a => a -> IO ()+sharedObject_printPtr' x = casADi__SharedObject__printPtr' (castSharedObject x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__SharedObject__init" c_CasADi__SharedObject__init+ :: Ptr SharedObject' -> IO ()+casADi__SharedObject__init+ :: SharedObject -> IO ()+casADi__SharedObject__init x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__SharedObject__init x0' >>= wrapReturn++-- classy wrapper+{-|+>Initialize or re-initialize the object: more documentation in the node class+>( SharedObjectNode and derived classes)+-}+sharedObject_init :: SharedObjectClass a => a -> IO ()+sharedObject_init x = casADi__SharedObject__init (castSharedObject x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__SharedObject__isInit" c_CasADi__SharedObject__isInit+ :: Ptr SharedObject' -> IO (Ptr CppBool')+casADi__SharedObject__isInit+ :: SharedObject -> IO Bool+casADi__SharedObject__isInit x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__SharedObject__isInit x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++-- classy wrapper+{-|+>Is initialized?+-}+sharedObject_isInit :: SharedObjectClass a => a -> IO Bool+sharedObject_isInit x = casADi__SharedObject__isInit (castSharedObject x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__SharedObject__assertInit" c_CasADi__SharedObject__assertInit+ :: Ptr SharedObject' -> IO ()+casADi__SharedObject__assertInit+ :: SharedObject -> IO ()+casADi__SharedObject__assertInit x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__SharedObject__assertInit x0' >>= wrapReturn++-- classy wrapper+{-|+>Assert that it is initialized.+-}+sharedObject_assertInit :: SharedObjectClass a => a -> IO ()+sharedObject_assertInit x = casADi__SharedObject__assertInit (castSharedObject x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__SharedObject__checkNode" c_CasADi__SharedObject__checkNode+ :: Ptr SharedObject' -> IO (Ptr CppBool')+casADi__SharedObject__checkNode+ :: SharedObject -> IO Bool+casADi__SharedObject__checkNode x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__SharedObject__checkNode x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++-- classy wrapper+{-|+>Assert that the node is pointing to the right type of object.+-}+sharedObject_checkNode :: SharedObjectClass a => a -> IO Bool+sharedObject_checkNode x = casADi__SharedObject__checkNode (castSharedObject x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__SharedObject__makeUnique" c_CasADi__SharedObject__makeUnique+ :: Ptr SharedObject' -> Ptr CppBool' -> IO ()+casADi__SharedObject__makeUnique+ :: SharedObject -> Bool -> IO ()+casADi__SharedObject__makeUnique x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__SharedObject__makeUnique x0' x1' >>= wrapReturn++-- classy wrapper+{-|+>If there are other references to the object, then make a deep copy of it and+>point to this new object.+-}+sharedObject_makeUnique :: SharedObjectClass a => a -> Bool -> IO ()+sharedObject_makeUnique x = casADi__SharedObject__makeUnique (castSharedObject x)+++-- direct wrapper+foreign import ccall unsafe "CasADi__SharedObject__makeUnique_TIC" c_CasADi__SharedObject__makeUnique_TIC+ :: Ptr SharedObject' -> IO ()+casADi__SharedObject__makeUnique'+ :: SharedObject -> IO ()+casADi__SharedObject__makeUnique' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__SharedObject__makeUnique_TIC x0' >>= wrapReturn++-- classy wrapper+sharedObject_makeUnique' :: SharedObjectClass a => a -> IO ()+sharedObject_makeUnique' x = casADi__SharedObject__makeUnique' (castSharedObject x)+
+ Casadi/Wrappers/Data.hs view
@@ -0,0 +1,4986 @@+{-# OPTIONS_GHC -Wall #-}+{-# Language FlexibleInstances #-}+{-# Language MultiParamTypeClasses #-}++module Casadi.Wrappers.Data where++import Prelude hiding ( Functor )++import Foreign.Ptr ( Ptr )+import Foreign.ForeignPtr ( ForeignPtr, castForeignPtr, withForeignPtr )++import Casadi.MarshalTypes ( ForeignPtrWrapper(..) )+import Casadi.Marshal ( Marshal(..) )+import Casadi.WrapReturn ( WrapReturn(..) )++-- raw decl+data SXFunction'+-- data decl+{-|+-}+newtype SXFunction = SXFunction (ForeignPtr SXFunction')+-- typeclass decl+class SXFunctionClass a where+ castSXFunction :: a -> SXFunction+instance SXFunctionClass SXFunction where+ castSXFunction = id++-- baseclass instances+instance SharedObjectClass SXFunction where+ castSharedObject (SXFunction x) = SharedObject (castForeignPtr x)++instance PrintableObjectClass SXFunction where+ castPrintableObject (SXFunction x) = PrintableObject (castForeignPtr x)++instance IOInterfaceFXClass SXFunction where+ castIOInterfaceFX (SXFunction x) = IOInterfaceFX (castForeignPtr x)++instance OptionsFunctionalityClass SXFunction where+ castOptionsFunctionality (SXFunction x) = OptionsFunctionality (castForeignPtr x)++instance FXClass SXFunction where+ castFX (SXFunction x) = FX (castForeignPtr x)+++-- helper instances+instance Marshal SXFunction (Ptr SXFunction') where+ withMarshal (SXFunction x) f = withForeignPtr x f+instance ForeignPtrWrapper SXFunction SXFunction' where+ unwrapForeignPtr (SXFunction x) = x+instance WrapReturn (ForeignPtr SXFunction') SXFunction where+ wrapReturn = return . SXFunction+++-- raw decl+data MXFunction'+-- data decl+{-|+>General function mapping from/to MX.+>+>Joel Andersson+>+>>List of available options+>+--------------+--------------+--------------+--------------+--------------++>| Id | Type | Default | Description | Used in |+>+==============+==============+==============+==============+==============++>| ad_mode | OT_STRING | "automatic" | How to | CasADi::FXIn |+>| | | | calculate | ternal |+>| | | | the | |+>| | | | Jacobians. | |+>| | | | (forward: | |+>| | | | only forward | |+>| | | | mode|reverse | |+>| | | | : only | |+>| | | | adjoint mode | |+>| | | | |automatic: | |+>| | | | a heuristic | |+>| | | | decides | |+>| | | | which is | |+>| | | | more | |+>| | | | appropriate) | |+>+--------------+--------------+--------------+--------------+--------------++>| gather_stats | OT_BOOLEAN | false | Flag to | CasADi::FXIn |+>| | | | indicate | ternal |+>| | | | wether | |+>| | | | statistics | |+>| | | | must be | |+>| | | | gathered | |+>+--------------+--------------+--------------+--------------+--------------++>| inputs_check | OT_BOOLEAN | true | Throw | CasADi::FXIn |+>| | | | exceptions | ternal |+>| | | | when the | |+>| | | | numerical | |+>| | | | values of | |+>| | | | the inputs | |+>| | | | don't make | |+>| | | | sense | |+>+--------------+--------------+--------------+--------------+--------------++>| jacobian_gen | OT_JACOBIANG | GenericType( | Function | CasADi::FXIn |+>| erator | ENERATOR | ) | that returns | ternal |+>| | | | a Jacobian | |+>| | | | function | |+>| | | | given a set | |+>| | | | of desired | |+>| | | | Jacobian | |+>| | | | blocks, | |+>| | | | overrides | |+>| | | | internal | |+>| | | | routines. | |+>| | | | Check docume | |+>| | | | ntation of J | |+>| | | | acobianGener | |+>| | | | ator . | |+>+--------------+--------------+--------------+--------------+--------------++>| max_number_o | OT_INTEGER | optimized_nu | Allow "numbe | CasADi::FXIn |+>| f_adj_dir | | m_dir | r_of_adj_dir | ternal |+>| | | | " to grow | |+>| | | | until it | |+>| | | | reaches this | |+>| | | | number | |+>+--------------+--------------+--------------+--------------+--------------++>| max_number_o | OT_INTEGER | optimized_nu | Allow "numbe | CasADi::FXIn |+>| f_fwd_dir | | m_dir | r_of_fwd_dir | ternal |+>| | | | " to grow | |+>| | | | until it | |+>| | | | reaches this | |+>| | | | number | |+>+--------------+--------------+--------------+--------------+--------------++>| monitor | OT_STRINGVEC | GenericType( | Monitors to | CasADi::FXIn |+>| | TOR | ) | be activated | ternal |+>| | | | (inputs|outp | |+>| | | | uts) | |+>+--------------+--------------+--------------+--------------+--------------++>| name | OT_STRING | "unnamed_sha | name of the | CasADi::Opti |+>| | | red_object" | object | onsFunctiona |+>| | | | | lityNode |+>+--------------+--------------+--------------+--------------+--------------++>| number_of_ad | OT_INTEGER | 1 | number of | CasADi::FXIn |+>| j_dir | | | adjoint | ternal |+>| | | | derivatives | |+>| | | | to be | |+>| | | | calculated s | |+>| | | | imultanously | |+>+--------------+--------------+--------------+--------------+--------------++>| number_of_fw | OT_INTEGER | 1 | number of | CasADi::FXIn |+>| d_dir | | | forward | ternal |+>| | | | derivatives | |+>| | | | to be | |+>| | | | calculated s | |+>| | | | imultanously | |+>+--------------+--------------+--------------+--------------+--------------++>| numeric_hess | OT_BOOLEAN | false | Calculate | CasADi::FXIn |+>| ian | | | Hessians | ternal |+>| | | | numerically | |+>| | | | (using | |+>| | | | directional | |+>| | | | derivatives) | |+>| | | | rather than | |+>| | | | with the | |+>| | | | built-in | |+>| | | | method | |+>+--------------+--------------+--------------+--------------+--------------++>| numeric_jaco | OT_BOOLEAN | false | Calculate | CasADi::FXIn |+>| bian | | | Jacobians | ternal |+>| | | | numerically | |+>| | | | (using | |+>| | | | directional | |+>| | | | derivatives) | |+>| | | | rather than | |+>| | | | with the | |+>| | | | built-in | |+>| | | | method | |+>+--------------+--------------+--------------+--------------+--------------++>| regularity_c | OT_BOOLEAN | true | Throw | CasADi::FXIn |+>| heck | | | exceptions | ternal |+>| | | | when NaN or | |+>| | | | Inf appears | |+>| | | | during | |+>| | | | evaluation | |+>+--------------+--------------+--------------+--------------+--------------++>| sparse | OT_BOOLEAN | true | function is | CasADi::FXIn |+>| | | | sparse | ternal |+>+--------------+--------------+--------------+--------------+--------------++>| sparsity_gen | OT_SPARSITYG | GenericType( | Function | CasADi::FXIn |+>| erator | ENERATOR | ) | that | ternal |+>| | | | provides | |+>| | | | sparsity for | |+>| | | | a given | |+>| | | | input output | |+>| | | | block, | |+>| | | | overrides | |+>| | | | internal | |+>| | | | routines. | |+>| | | | Check docume | |+>| | | | ntation of S | |+>| | | | parsityGener | |+>| | | | ator . | |+>+--------------+--------------+--------------+--------------+--------------++>| store_jacobi | OT_BOOLEAN | false | keep | CasADi::FXIn |+>| ans | | | references | ternal |+>| | | | to generated | |+>| | | | Jacobians in | |+>| | | | order to | |+>| | | | avoid | |+>| | | | generating | |+>| | | | identical | |+>| | | | Jacobians | |+>| | | | multiple | |+>| | | | times | |+>+--------------+--------------+--------------+--------------+--------------++>| user_data | OT_VOIDPTR | GenericType( | A user- | CasADi::FXIn |+>| | | ) | defined | ternal |+>| | | | field that | |+>| | | | can be used | |+>| | | | to identify | |+>| | | | the function | |+>| | | | or pass | |+>| | | | additional | |+>| | | | information | |+>+--------------+--------------+--------------+--------------+--------------++>| verbose | OT_BOOLEAN | false | verbose | CasADi::FXIn |+>| | | | evaluation | ternal |+>| | | | for | |+>| | | | debugging | |+>+--------------+--------------+--------------+--------------+--------------++>+>Diagrams+>+>C++ includes: mx_function.hpp +-}+newtype MXFunction = MXFunction (ForeignPtr MXFunction')+-- typeclass decl+class MXFunctionClass a where+ castMXFunction :: a -> MXFunction+instance MXFunctionClass MXFunction where+ castMXFunction = id++-- baseclass instances+instance SharedObjectClass MXFunction where+ castSharedObject (MXFunction x) = SharedObject (castForeignPtr x)++instance PrintableObjectClass MXFunction where+ castPrintableObject (MXFunction x) = PrintableObject (castForeignPtr x)++instance IOInterfaceFXClass MXFunction where+ castIOInterfaceFX (MXFunction x) = IOInterfaceFX (castForeignPtr x)++instance OptionsFunctionalityClass MXFunction where+ castOptionsFunctionality (MXFunction x) = OptionsFunctionality (castForeignPtr x)++instance FXClass MXFunction where+ castFX (MXFunction x) = FX (castForeignPtr x)+++-- helper instances+instance Marshal MXFunction (Ptr MXFunction') where+ withMarshal (MXFunction x) f = withForeignPtr x f+instance ForeignPtrWrapper MXFunction MXFunction' where+ unwrapForeignPtr (MXFunction x) = x+instance WrapReturn (ForeignPtr MXFunction') MXFunction where+ wrapReturn = return . MXFunction+++-- raw decl+data FX'+-- data decl+{-|+>General function.+>+>A general function $f$ in casadi can be multi-input, multi-output. Number+>of inputs: nin getNumInputs() Number of outputs: nout getNumOutputs()+>+>We can view this function as a being composed of a (nin, nout) grid of+>single-input, single-output primitive functions. Each such primitive+>function $f_{i,j} \\forall i \\in [0,nin-1], j \\in [0,nout-1]$ can+>map as $\\mathbf{R}^{n,m}\\to\\mathbf{R}^{p,q}$, in which n,m,p,q can+>take different values for every (i,j) pair.+>+>When passing input, you specify which partition i is active. You pass the+>numbers flattened, as a vector of size $(n*m)$. When requesting output, you+>specify which partition j is active. You get the numbers flattened, as a+>vector of size $(p*q)$.+>+>To calculate jacobians, you need to have $(m=1,q=1)$.+>+>Write the jacobian as $J_{i,j} = \\nabla f_{i,j} = \\frac{\\partial+>f_{i,j}(\\vec{x})}{\\partial \\vec{x}}$.+>+>Using $\\vec{v} \\in \\mathbf{R}^n$ as a forward seed: setFwdSeed(v,i)+>Retrieving $\\vec{s}_f \\in \\mathbf{R}^p$ from: getFwdSens(sf,j)+>+>Using $\\vec{w} \\in \\mathbf{R}^p$ as a forward seed: setAdjSeed(w,j)+>Retrieving $\\vec{s}_a \\in \\mathbf{R}^n $ from: getAdjSens(sa,i)+>+>We have the following relationships for function mapping from a column+>vector to a column vector:+>+>$ \\vec{s}_f = \\nabla f_{i,j} . \\vec{v}$ $ \\vec{s}_a = (\\nabla+>f_{i,j})^T . \\vec{w}$+>+>Some quantities is these formulas must be transposed: input row: transpose+>$ \\vec{v} $ and $\\vec{s}_a$ output row: transpose $ \\vec{w} $ and+>$\\vec{s}_f$+>+>NOTE: FX's are allowed to modify their input arguments when evaluating:+>implicitFunction, IDAS solver Futher releases may disallow this. for+>developers Each function consists of 4 files: public class header file:+>imported in python+>+>public class implementation+>+>internal class header file: should only be used by derived classes+>+>internal class implementation+>+>python and c++ should be 1-to-1 There should be no extra features in 1.+>All the functionality should exist in 1. If it means that c++ will be more+>"pythonic", so be it.+>+>Joel Andersson+>+>>List of available options+>+--------------+--------------+--------------+--------------+--------------++>| Id | Type | Default | Description | Used in |+>+==============+==============+==============+==============+==============++>| ad_mode | OT_STRING | "automatic" | How to | CasADi::FXIn |+>| | | | calculate | ternal |+>| | | | the | |+>| | | | Jacobians. | |+>| | | | (forward: | |+>| | | | only forward | |+>| | | | mode|reverse | |+>| | | | : only | |+>| | | | adjoint mode | |+>| | | | |automatic: | |+>| | | | a heuristic | |+>| | | | decides | |+>| | | | which is | |+>| | | | more | |+>| | | | appropriate) | |+>+--------------+--------------+--------------+--------------+--------------++>| gather_stats | OT_BOOLEAN | false | Flag to | CasADi::FXIn |+>| | | | indicate | ternal |+>| | | | wether | |+>| | | | statistics | |+>| | | | must be | |+>| | | | gathered | |+>+--------------+--------------+--------------+--------------+--------------++>| inputs_check | OT_BOOLEAN | true | Throw | CasADi::FXIn |+>| | | | exceptions | ternal |+>| | | | when the | |+>| | | | numerical | |+>| | | | values of | |+>| | | | the inputs | |+>| | | | don't make | |+>| | | | sense | |+>+--------------+--------------+--------------+--------------+--------------++>| jacobian_gen | OT_JACOBIANG | GenericType( | Function | CasADi::FXIn |+>| erator | ENERATOR | ) | that returns | ternal |+>| | | | a Jacobian | |+>| | | | function | |+>| | | | given a set | |+>| | | | of desired | |+>| | | | Jacobian | |+>| | | | blocks, | |+>| | | | overrides | |+>| | | | internal | |+>| | | | routines. | |+>| | | | Check docume | |+>| | | | ntation of J | |+>| | | | acobianGener | |+>| | | | ator . | |+>+--------------+--------------+--------------+--------------+--------------++>| max_number_o | OT_INTEGER | optimized_nu | Allow "numbe | CasADi::FXIn |+>| f_adj_dir | | m_dir | r_of_adj_dir | ternal |+>| | | | " to grow | |+>| | | | until it | |+>| | | | reaches this | |+>| | | | number | |+>+--------------+--------------+--------------+--------------+--------------++>| max_number_o | OT_INTEGER | optimized_nu | Allow "numbe | CasADi::FXIn |+>| f_fwd_dir | | m_dir | r_of_fwd_dir | ternal |+>| | | | " to grow | |+>| | | | until it | |+>| | | | reaches this | |+>| | | | number | |+>+--------------+--------------+--------------+--------------+--------------++>| monitor | OT_STRINGVEC | GenericType( | Monitors to | CasADi::FXIn |+>| | TOR | ) | be activated | ternal |+>| | | | (inputs|outp | |+>| | | | uts) | |+>+--------------+--------------+--------------+--------------+--------------++>| name | OT_STRING | "unnamed_sha | name of the | CasADi::Opti |+>| | | red_object" | object | onsFunctiona |+>| | | | | lityNode |+>+--------------+--------------+--------------+--------------+--------------++>| number_of_ad | OT_INTEGER | 1 | number of | CasADi::FXIn |+>| j_dir | | | adjoint | ternal |+>| | | | derivatives | |+>| | | | to be | |+>| | | | calculated s | |+>| | | | imultanously | |+>+--------------+--------------+--------------+--------------+--------------++>| number_of_fw | OT_INTEGER | 1 | number of | CasADi::FXIn |+>| d_dir | | | forward | ternal |+>| | | | derivatives | |+>| | | | to be | |+>| | | | calculated s | |+>| | | | imultanously | |+>+--------------+--------------+--------------+--------------+--------------++>| numeric_hess | OT_BOOLEAN | false | Calculate | CasADi::FXIn |+>| ian | | | Hessians | ternal |+>| | | | numerically | |+>| | | | (using | |+>| | | | directional | |+>| | | | derivatives) | |+>| | | | rather than | |+>| | | | with the | |+>| | | | built-in | |+>| | | | method | |+>+--------------+--------------+--------------+--------------+--------------++>| numeric_jaco | OT_BOOLEAN | false | Calculate | CasADi::FXIn |+>| bian | | | Jacobians | ternal |+>| | | | numerically | |+>| | | | (using | |+>| | | | directional | |+>| | | | derivatives) | |+>| | | | rather than | |+>| | | | with the | |+>| | | | built-in | |+>| | | | method | |+>+--------------+--------------+--------------+--------------+--------------++>| regularity_c | OT_BOOLEAN | true | Throw | CasADi::FXIn |+>| heck | | | exceptions | ternal |+>| | | | when NaN or | |+>| | | | Inf appears | |+>| | | | during | |+>| | | | evaluation | |+>+--------------+--------------+--------------+--------------+--------------++>| sparse | OT_BOOLEAN | true | function is | CasADi::FXIn |+>| | | | sparse | ternal |+>+--------------+--------------+--------------+--------------+--------------++>| sparsity_gen | OT_SPARSITYG | GenericType( | Function | CasADi::FXIn |+>| erator | ENERATOR | ) | that | ternal |+>| | | | provides | |+>| | | | sparsity for | |+>| | | | a given | |+>| | | | input output | |+>| | | | block, | |+>| | | | overrides | |+>| | | | internal | |+>| | | | routines. | |+>| | | | Check docume | |+>| | | | ntation of S | |+>| | | | parsityGener | |+>| | | | ator . | |+>+--------------+--------------+--------------+--------------+--------------++>| store_jacobi | OT_BOOLEAN | false | keep | CasADi::FXIn |+>| ans | | | references | ternal |+>| | | | to generated | |+>| | | | Jacobians in | |+>| | | | order to | |+>| | | | avoid | |+>| | | | generating | |+>| | | | identical | |+>| | | | Jacobians | |+>| | | | multiple | |+>| | | | times | |+>+--------------+--------------+--------------+--------------+--------------++>| user_data | OT_VOIDPTR | GenericType( | A user- | CasADi::FXIn |+>| | | ) | defined | ternal |+>| | | | field that | |+>| | | | can be used | |+>| | | | to identify | |+>| | | | the function | |+>| | | | or pass | |+>| | | | additional | |+>| | | | information | |+>+--------------+--------------+--------------+--------------+--------------++>| verbose | OT_BOOLEAN | false | verbose | CasADi::FXIn |+>| | | | evaluation | ternal |+>| | | | for | |+>| | | | debugging | |+>+--------------+--------------+--------------+--------------+--------------++>+>>List of available monitors+>+---------+--------------------++>| Id | Used in |+>+=========+====================++>| inputs | CasADi::FXInternal |+>+---------+--------------------++>| outputs | CasADi::FXInternal |+>+---------+--------------------++>+>Diagrams+>+>C++ includes: fx.hpp +-}+newtype FX = FX (ForeignPtr FX')+-- typeclass decl+class FXClass a where+ castFX :: a -> FX+instance FXClass FX where+ castFX = id++-- baseclass instances+instance SharedObjectClass FX where+ castSharedObject (FX x) = SharedObject (castForeignPtr x)++instance PrintableObjectClass FX where+ castPrintableObject (FX x) = PrintableObject (castForeignPtr x)++instance IOInterfaceFXClass FX where+ castIOInterfaceFX (FX x) = IOInterfaceFX (castForeignPtr x)++instance OptionsFunctionalityClass FX where+ castOptionsFunctionality (FX x) = OptionsFunctionality (castForeignPtr x)+++-- helper instances+instance Marshal FX (Ptr FX') where+ withMarshal (FX x) f = withForeignPtr x f+instance ForeignPtrWrapper FX FX' where+ unwrapForeignPtr (FX x) = x+instance WrapReturn (ForeignPtr FX') FX where+ wrapReturn = return . FX+++-- raw decl+data SharedObject'+-- data decl+{-|+>SharedObject implements a reference counting framework simular for effient+>and easily-maintained memory management.+>+>To use the class, both the SharedObject class (the public class), and the+>SharedObjectNode class (the internal class) must be inherited from. It can+>be done in two different files and together with memory management, this+>approach provides a clear destinction of which methods of the class are to+>be considered "public", i.e. methods for public use that can be considered+>to remain over time with small changes, and the internal memory.+>+>When interfacing a software, which typically includes including some header+>file, this is best done only in the file where the internal class is+>defined, to avoid polluting the global namespace and other side effects.+>+>The default constructor always means creating a null pointer to an internal+>class only. To allocate an internal class (this works only when the internal+>class isn't abstract), use the constructor with arguments.+>+>The copy constructor and the assignment operator perform shallow copies+>only, to make a deep copy you must use the clone method explictly. This will+>give a shared pointer instance.+>+>In an inheritance hierarchy, you can cast down automatically, e.g. (+>SXFunction is a child class of FX): SXFunction derived(...); FX base =+>derived;+>+>To cast up, use the shared_cast template function, which works analogously+>to dynamic_cast, static_cast, const_cast etc, e.g.: SXFunction derived(...);+>FX base = derived; SXFunction derived_from_base =+>shared_cast<SXFunction>(base);+>+>A failed shared_cast will result in a null pointer (cf. dynamic_cast)+>+>Joel Andersson+>+>C++ includes: shared_object.hpp +-}+newtype SharedObject = SharedObject (ForeignPtr SharedObject')+-- typeclass decl+class SharedObjectClass a where+ castSharedObject :: a -> SharedObject+instance SharedObjectClass SharedObject where+ castSharedObject = id++-- baseclass instances+instance PrintableObjectClass SharedObject where+ castPrintableObject (SharedObject x) = PrintableObject (castForeignPtr x)+++-- helper instances+instance Marshal SharedObject (Ptr SharedObject') where+ withMarshal (SharedObject x) f = withForeignPtr x f+instance ForeignPtrWrapper SharedObject SharedObject' where+ unwrapForeignPtr (SharedObject x) = x+instance WrapReturn (ForeignPtr SharedObject') SharedObject where+ wrapReturn = return . SharedObject+++-- raw decl+data PrintableObject'+-- data decl+{-|+>Base class for objects that have a natural string representation.+>+>Joel Andersson+>+>C++ includes: printable_object.hpp +-}+newtype PrintableObject = PrintableObject (ForeignPtr PrintableObject')+-- typeclass decl+class PrintableObjectClass a where+ castPrintableObject :: a -> PrintableObject+instance PrintableObjectClass PrintableObject where+ castPrintableObject = id++-- baseclass instances++-- helper instances+instance Marshal PrintableObject (Ptr PrintableObject') where+ withMarshal (PrintableObject x) f = withForeignPtr x f+instance ForeignPtrWrapper PrintableObject PrintableObject' where+ unwrapForeignPtr (PrintableObject x) = x+instance WrapReturn (ForeignPtr PrintableObject') PrintableObject where+ wrapReturn = return . PrintableObject+++-- raw decl+data CRSSparsity'+-- data decl+{-|+>General sparsity class.+>+>The storage format is a compressed row storage (CRS) format.+>+>In this format, the structural non-zero elements are stored in row- major+>order, starting from the upper left corner of the matrix and ending in the+>lower right corner.+>+>In addition to the dimension ( size1(), size2()), (i.e. the number of rows+>and the number of columns respectively), there are also two vectors of+>integers:+>+>"rowind" [length size1()+1], which contains the index to the first non-+>zero element on or after the corresponding row. All the non-zero elements of+>a particular i are thus the elements with index el that fulfils: rowind[i]+><= el < rowind[i+1].+>+>"col" [same length as the number of non-zero elements, size()] The columns+>for each of the structural non-zeros.+>+>Note that with this format, it is cheap to loop over all the non-zero+>elements of a particular row, constant time per elment, but expensive to+>jump to access a location (i,j).+>+>If the matrix is dense, i.e. length(col) == size1()*size2(), the format+>reduces to standard dense row major format, which allows access to an+>arbitrary element in constant time.+>+>Since the object is reference counted (it inherits from SharedObject),+>several matrices are allowed to share the same sparsity pattern.+>+>The implementations of some methods of this class has been taken from the+>CSparse package and modified to use STL and CasADi data structures.+>+>See: Matrix+>+>Joel Andersson+>+>C++ includes: crs_sparsity.hpp +-}+newtype CRSSparsity = CRSSparsity (ForeignPtr CRSSparsity')+-- typeclass decl+class CRSSparsityClass a where+ castCRSSparsity :: a -> CRSSparsity+instance CRSSparsityClass CRSSparsity where+ castCRSSparsity = id++-- baseclass instances+instance SharedObjectClass CRSSparsity where+ castSharedObject (CRSSparsity x) = SharedObject (castForeignPtr x)++instance PrintableObjectClass CRSSparsity where+ castPrintableObject (CRSSparsity x) = PrintableObject (castForeignPtr x)+++-- helper instances+instance Marshal CRSSparsity (Ptr CRSSparsity') where+ withMarshal (CRSSparsity x) f = withForeignPtr x f+instance ForeignPtrWrapper CRSSparsity CRSSparsity' where+ unwrapForeignPtr (CRSSparsity x) = x+instance WrapReturn (ForeignPtr CRSSparsity') CRSSparsity where+ wrapReturn = return . CRSSparsity+++-- raw decl+data GenericType'+-- data decl+{-|+>Generic data type.+>+>Joel Andersson+>+>C++ includes: generic_type.hpp +-}+newtype GenericType = GenericType (ForeignPtr GenericType')+-- typeclass decl+class GenericTypeClass a where+ castGenericType :: a -> GenericType+instance GenericTypeClass GenericType where+ castGenericType = id++-- baseclass instances+instance SharedObjectClass GenericType where+ castSharedObject (GenericType x) = SharedObject (castForeignPtr x)++instance PrintableObjectClass GenericType where+ castPrintableObject (GenericType x) = PrintableObject (castForeignPtr x)+++-- helper instances+instance Marshal GenericType (Ptr GenericType') where+ withMarshal (GenericType x) f = withForeignPtr x f+instance ForeignPtrWrapper GenericType GenericType' where+ unwrapForeignPtr (GenericType x) = x+instance WrapReturn (ForeignPtr GenericType') GenericType where+ wrapReturn = return . GenericType+++-- raw decl+data IOInterfaceFX'+-- data decl+{-|+>Interface for accessing input and output data structures.+>+>Joel Andersson+>+>C++ includes: io_interface.hpp +-}+newtype IOInterfaceFX = IOInterfaceFX (ForeignPtr IOInterfaceFX')+-- typeclass decl+class IOInterfaceFXClass a where+ castIOInterfaceFX :: a -> IOInterfaceFX+instance IOInterfaceFXClass IOInterfaceFX where+ castIOInterfaceFX = id++-- baseclass instances++-- helper instances+instance Marshal IOInterfaceFX (Ptr IOInterfaceFX') where+ withMarshal (IOInterfaceFX x) f = withForeignPtr x f+instance ForeignPtrWrapper IOInterfaceFX IOInterfaceFX' where+ unwrapForeignPtr (IOInterfaceFX x) = x+instance WrapReturn (ForeignPtr IOInterfaceFX') IOInterfaceFX where+ wrapReturn = return . IOInterfaceFX+++-- raw decl+data OptionsFunctionality'+-- data decl+{-|+>Provides options setting/getting functionality Gives a derived class the+>ability to set and retrieve options in a convenient way. It also contains+>error checking, making sure that the option exists and that the value type+>is correct.+>+>A derived class should add option names, types and default values to the+>corresponding vectors.+>+>Joel Andersson+>+>>List of available options+>+--------------+--------------+--------------+--------------+--------------++>| Id | Type | Default | Description | Used in |+>+==============+==============+==============+==============+==============++>| name | OT_STRING | "unnamed_sha | name of the | CasADi::Opti |+>| | | red_object" | object | onsFunctiona |+>| | | | | lityNode |+>+--------------+--------------+--------------+--------------+--------------++>+>Diagrams+>+>C++ includes: options_functionality.hpp +-}+newtype OptionsFunctionality = OptionsFunctionality (ForeignPtr OptionsFunctionality')+-- typeclass decl+class OptionsFunctionalityClass a where+ castOptionsFunctionality :: a -> OptionsFunctionality+instance OptionsFunctionalityClass OptionsFunctionality where+ castOptionsFunctionality = id++-- baseclass instances+instance SharedObjectClass OptionsFunctionality where+ castSharedObject (OptionsFunctionality x) = SharedObject (castForeignPtr x)++instance PrintableObjectClass OptionsFunctionality where+ castPrintableObject (OptionsFunctionality x) = PrintableObject (castForeignPtr x)+++-- helper instances+instance Marshal OptionsFunctionality (Ptr OptionsFunctionality') where+ withMarshal (OptionsFunctionality x) f = withForeignPtr x f+instance ForeignPtrWrapper OptionsFunctionality OptionsFunctionality' where+ unwrapForeignPtr (OptionsFunctionality x) = x+instance WrapReturn (ForeignPtr OptionsFunctionality') OptionsFunctionality where+ wrapReturn = return . OptionsFunctionality+++-- raw decl+data IpoptSolver'+-- data decl+{-|+>interface to IPOPT NLP solver+>+>Solves the following parametric nonlinear program (NLP):min F(x,p)+>x subject to LBX <= x <= UBX LBG <= G(x,p) <= UBG+>p == P nx: number of decision variables ng: number of constraints+>np: number of parameters+>+>When in warmstart mode, output NLP_SOLVER_LAM_X may be used as input+>+>NOTE: Even when max_iter == 0, it is not guaranteed that+>input(NLP_SOLVER_X0) == output(NLP_SOLVER_X). Indeed if bounds on X or+>constraints are unmet, they will differ.+>+>For a good tutorial on IPOPT,+>seehttp://drops.dagstuhl.de/volltexte/2009/2089/pdf/09061.WaechterAndreas.Paper.2089.pdf+>+>A good resource about the algorithms in IPOPT is: Wachter and L. T. Biegler,+>On the Implementation of an Interior-Point Filter Line-Search Algorithm for+>Large-Scale Nonlinear Programming, Mathematical Programming 106(1), pp.+>25-57, 2006 (As Research Report RC 23149, IBM T. J. Watson Research Center,+>Yorktown, USA+>+>Caveats: with default options, multipliers for the decision variables are+>wrong for equality constraints. Change the 'fixed_variable_treatment' to+>'make_constraint' or 'relax_bounds' to obtain correct results.+>+>>Input scheme: CasADi::NLPSolverInput (NLP_SOLVER_NUM_IN = 9) [nlpSolverIn]+>+------------------------+------------------------+------------------------++>| Full name | Short | Description |+>+========================+========================+========================++>| NLP_SOLVER_X0 | x0 | Decision variables, |+>| | | initial guess (nx x 1) |+>| | | . |+>+------------------------+------------------------+------------------------++>| NLP_SOLVER_P | p | Value of fixed |+>| | | parameters (np x 1) . |+>+------------------------+------------------------+------------------------++>| NLP_SOLVER_LBX | lbx | Decision variables |+>| | | lower bound (nx x 1), |+>| | | default -inf . |+>+------------------------+------------------------+------------------------++>| NLP_SOLVER_UBX | ubx | Decision variables |+>| | | upper bound (nx x 1), |+>| | | default +inf . |+>+------------------------+------------------------+------------------------++>| NLP_SOLVER_LBG | lbg | Constraints lower |+>| | | bound (ng x 1), |+>| | | default -inf . |+>+------------------------+------------------------+------------------------++>| NLP_SOLVER_UBG | ubg | Constraints upper |+>| | | bound (ng x 1), |+>| | | default +inf . |+>+------------------------+------------------------+------------------------++>| NLP_SOLVER_LAM_X0 | lam_x0 | Lagrange multipliers |+>| | | for bounds on X, |+>| | | initial guess (nx x 1) |+>| | | . |+>+------------------------+------------------------+------------------------++>| NLP_SOLVER_LAM_G0 | lam_g0 | Lagrange multipliers |+>| | | for bounds on G, |+>| | | initial guess (ng x 1) |+>| | | . |+>+------------------------+------------------------+------------------------++>+>>Output scheme: CasADi::NLPSolverOutput (NLP_SOLVER_NUM_OUT = 7) [nlpSolverOut]+>+------------------------+------------------------+------------------------++>| Full name | Short | Description |+>+========================+========================+========================++>| NLP_SOLVER_X | x | Decision variables at |+>| | | the optimal solution |+>| | | (nx x 1) . |+>+------------------------+------------------------+------------------------++>| NLP_SOLVER_F | f | Cost function value at |+>| | | the optimal solution |+>| | | (1 x 1) . |+>+------------------------+------------------------+------------------------++>| NLP_SOLVER_G | g | Constraints function |+>| | | at the optimal |+>| | | solution (ng x 1) . |+>+------------------------+------------------------+------------------------++>| NLP_SOLVER_LAM_X | lam_x | Lagrange multipliers |+>| | | for bounds on X at the |+>| | | solution (nx x 1) . |+>+------------------------+------------------------+------------------------++>| NLP_SOLVER_LAM_G | lam_g | Lagrange multipliers |+>| | | for bounds on G at the |+>| | | solution (ng x 1) . |+>+------------------------+------------------------+------------------------++>| NLP_SOLVER_LAM_P | lam_p | Lagrange multipliers |+>| | | for bounds on P at the |+>| | | solution (np x 1) . |+>+------------------------+------------------------+------------------------++>+>>List of available options+>+--------------+--------------+--------------+--------------+--------------++>| Id | Type | Default | Description | Used in |+>+==============+==============+==============+==============+==============++>| accept_after | OT_INTEGER | -1 | Accept a | CasADi::Ipop |+>| _max_steps | | | trial point | tInternal |+>| | | | after | |+>| | | | maximal this | |+>| | | | number of | |+>| | | | steps. (see | |+>| | | | IPOPT docume | |+>| | | | ntation) | |+>+--------------+--------------+--------------+--------------+--------------++>| accept_every | OT_STRING | no | Always | CasADi::Ipop |+>| _trial_step | | | accept the | tInternal |+>| | | | first trial | |+>| | | | step. (see | |+>| | | | IPOPT docume | |+>| | | | ntation) | |+>+--------------+--------------+--------------+--------------+--------------++>| acceptable_c | OT_REAL | 0.010 | "Acceptance" | CasADi::Ipop |+>| ompl_inf_tol | | | threshold | tInternal |+>| | | | for the comp | |+>| | | | lementarity | |+>| | | | conditions. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| acceptable_c | OT_REAL | 0.010 | "Acceptance" | CasADi::Ipop |+>| onstr_viol_t | | | threshold | tInternal |+>| ol | | | for the | |+>| | | | constraint | |+>| | | | violation. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| acceptable_d | OT_REAL | 1.000e+10 | "Acceptance" | CasADi::Ipop |+>| ual_inf_tol | | | threshold | tInternal |+>| | | | for the dual | |+>| | | | infeasibilit | |+>| | | | y. (see | |+>| | | | IPOPT docume | |+>| | | | ntation) | |+>+--------------+--------------+--------------+--------------+--------------++>| acceptable_i | OT_INTEGER | 15 | Number of | CasADi::Ipop |+>| ter | | | "acceptable" | tInternal |+>| | | | iterates | |+>| | | | before | |+>| | | | triggering | |+>| | | | termination. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| acceptable_o | OT_REAL | 1.000e+20 | "Acceptance" | CasADi::Ipop |+>| bj_change_to | | | stopping | tInternal |+>| l | | | criterion | |+>| | | | based on | |+>| | | | objective | |+>| | | | function | |+>| | | | change. (see | |+>| | | | IPOPT docume | |+>| | | | ntation) | |+>+--------------+--------------+--------------+--------------+--------------++>| acceptable_t | OT_REAL | 0.000 | "Acceptable" | CasADi::Ipop |+>| ol | | | convergence | tInternal |+>| | | | tolerance | |+>| | | | (relative). | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| ad_mode | OT_STRING | "automatic" | How to | CasADi::FXIn |+>| | | | calculate | ternal |+>| | | | the | |+>| | | | Jacobians. | |+>| | | | (forward: | |+>| | | | only forward | |+>| | | | mode|reverse | |+>| | | | : only | |+>| | | | adjoint mode | |+>| | | | |automatic: | |+>| | | | a heuristic | |+>| | | | decides | |+>| | | | which is | |+>| | | | more | |+>| | | | appropriate) | |+>+--------------+--------------+--------------+--------------+--------------++>| adaptive_mu_ | OT_STRING | obj-constr- | Globalizatio | CasADi::Ipop |+>| globalizatio | | filter | n strategy | tInternal |+>| n | | | for the | |+>| | | | adaptive mu | |+>| | | | selection | |+>| | | | mode. (see | |+>| | | | IPOPT docume | |+>| | | | ntation) | |+>+--------------+--------------+--------------+--------------+--------------++>| adaptive_mu_ | OT_STRING | 2-norm- | Norm used | CasADi::Ipop |+>| kkt_norm_typ | | squared | for the KKT | tInternal |+>| e | | | error in the | |+>| | | | adaptive mu | |+>| | | | globalizatio | |+>| | | | n | |+>| | | | strategies. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| adaptive_mu_ | OT_REAL | 1.000 | Sufficient | CasADi::Ipop |+>| kkterror_red | | | decrease | tInternal |+>| _fact | | | factor for | |+>| | | | "kkt-error" | |+>| | | | globalizatio | |+>| | | | n strategy. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| adaptive_mu_ | OT_INTEGER | 4 | Maximum | CasADi::Ipop |+>| kkterror_red | | | number of | tInternal |+>| _iters | | | iterations | |+>| | | | requiring | |+>| | | | sufficient | |+>| | | | progress. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| adaptive_mu_ | OT_REAL | 0.800 | Determines | CasADi::Ipop |+>| monotone_ini | | | the initial | tInternal |+>| t_factor | | | value of the | |+>| | | | barrier | |+>| | | | parameter | |+>| | | | when | |+>| | | | switching to | |+>| | | | the monotone | |+>| | | | mode. (see | |+>| | | | IPOPT docume | |+>| | | | ntation) | |+>+--------------+--------------+--------------+--------------+--------------++>| adaptive_mu_ | OT_STRING | no | Indicates if | CasADi::Ipop |+>| restore_prev | | | the previous | tInternal |+>| ious_iterate | | | iterate | |+>| | | | should be | |+>| | | | restored if | |+>| | | | the monotone | |+>| | | | mode is | |+>| | | | entered. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| adaptive_mu_ | OT_REAL | 0 | (see IPOPT d | CasADi::Ipop |+>| safeguard_fa | | | ocumentation | tInternal |+>| ctor | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| alpha_for_y | OT_STRING | primal | Method to | CasADi::Ipop |+>| | | | determine | tInternal |+>| | | | the step | |+>| | | | size for | |+>| | | | constraint | |+>| | | | multipliers. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| alpha_for_y_ | OT_REAL | 10 | Tolerance | CasADi::Ipop |+>| tol | | | for | tInternal |+>| | | | switching to | |+>| | | | full | |+>| | | | equality | |+>| | | | multiplier | |+>| | | | steps. (see | |+>| | | | IPOPT docume | |+>| | | | ntation) | |+>+--------------+--------------+--------------+--------------+--------------++>| alpha_min_fr | OT_REAL | 0.050 | Safety | CasADi::Ipop |+>| ac | | | factor for | tInternal |+>| | | | the minimal | |+>| | | | step size | |+>| | | | (before | |+>| | | | switching to | |+>| | | | restoration | |+>| | | | phase). (see | |+>| | | | IPOPT docume | |+>| | | | ntation) | |+>+--------------+--------------+--------------+--------------+--------------++>| alpha_red_fa | OT_REAL | 0.500 | Fractional | CasADi::Ipop |+>| ctor | | | reduction of | tInternal |+>| | | | the trial | |+>| | | | step size in | |+>| | | | the | |+>| | | | backtracking | |+>| | | | line search. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| barrier_tol_ | OT_REAL | 10 | Factor for | CasADi::Ipop |+>| factor | | | mu in | tInternal |+>| | | | barrier stop | |+>| | | | test. (see | |+>| | | | IPOPT docume | |+>| | | | ntation) | |+>+--------------+--------------+--------------+--------------+--------------++>| bound_frac | OT_REAL | 0.010 | Desired | CasADi::Ipop |+>| | | | minimum | tInternal |+>| | | | relative | |+>| | | | distance | |+>| | | | from the | |+>| | | | initial | |+>| | | | point to | |+>| | | | bound. (see | |+>| | | | IPOPT docume | |+>| | | | ntation) | |+>+--------------+--------------+--------------+--------------+--------------++>| bound_mult_i | OT_STRING | constant | Initializati | CasADi::Ipop |+>| nit_method | | | on method | tInternal |+>| | | | for bound | |+>| | | | multipliers | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| bound_mult_i | OT_REAL | 1 | Initial | CasADi::Ipop |+>| nit_val | | | value for | tInternal |+>| | | | the bound | |+>| | | | multipliers. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| bound_mult_r | OT_REAL | 1000 | Threshold | CasADi::Ipop |+>| eset_thresho | | | for | tInternal |+>| ld | | | resetting | |+>| | | | bound | |+>| | | | multipliers | |+>| | | | after the | |+>| | | | restoration | |+>| | | | phase. (see | |+>| | | | IPOPT docume | |+>| | | | ntation) | |+>+--------------+--------------+--------------+--------------+--------------++>| bound_push | OT_REAL | 0.010 | Desired | CasADi::Ipop |+>| | | | minimum | tInternal |+>| | | | absolute | |+>| | | | distance | |+>| | | | from the | |+>| | | | initial | |+>| | | | point to | |+>| | | | bound. (see | |+>| | | | IPOPT docume | |+>| | | | ntation) | |+>+--------------+--------------+--------------+--------------+--------------++>| bound_relax_ | OT_REAL | 0.000 | Factor for | CasADi::Ipop |+>| factor | | | initial | tInternal |+>| | | | relaxation | |+>| | | | of the | |+>| | | | bounds. (see | |+>| | | | IPOPT docume | |+>| | | | ntation) | |+>+--------------+--------------+--------------+--------------+--------------++>| check_deriva | OT_STRING | no | Indicates | CasADi::Ipop |+>| tives_for_na | | | whether it | tInternal |+>| ninf | | | is desired | |+>| | | | to check for | |+>| | | | Nan/Inf in | |+>| | | | derivative | |+>| | | | matrices | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| chi_cup | OT_REAL | 1.500 | LIFENG | CasADi::Ipop |+>| | | | WRITES THIS. | tInternal |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| chi_hat | OT_REAL | 2 | LIFENG | CasADi::Ipop |+>| | | | WRITES THIS. | tInternal |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| chi_tilde | OT_REAL | 5 | LIFENG | CasADi::Ipop |+>| | | | WRITES THIS. | tInternal |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| compl_inf_to | OT_REAL | 0.000 | Desired | CasADi::Ipop |+>| l | | | threshold | tInternal |+>| | | | for the comp | |+>| | | | lementarity | |+>| | | | conditions. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| con_integer_ | OT_DICTIONAR | None | Integer | CasADi::Ipop |+>| md | Y | | metadata (a | tInternal |+>| | | | dictionary | |+>| | | | with lists | |+>| | | | of integers) | |+>| | | | about | |+>| | | | constraints | |+>| | | | to be passed | |+>| | | | to IPOPT | |+>+--------------+--------------+--------------+--------------+--------------++>| con_numeric_ | OT_DICTIONAR | None | Numeric | CasADi::Ipop |+>| md | Y | | metadata (a | tInternal |+>| | | | dictionary | |+>| | | | with lists | |+>| | | | of reals) | |+>| | | | about | |+>| | | | constraints | |+>| | | | to be passed | |+>| | | | to IPOPT | |+>+--------------+--------------+--------------+--------------+--------------++>| con_string_m | OT_DICTIONAR | None | String | CasADi::Ipop |+>| d | Y | | metadata (a | tInternal |+>| | | | dictionary | |+>| | | | with lists | |+>| | | | of strings) | |+>| | | | about | |+>| | | | constraints | |+>| | | | to be passed | |+>| | | | to IPOPT | |+>+--------------+--------------+--------------+--------------+--------------++>| constr_mult_ | OT_REAL | 1000 | Maximum | CasADi::Ipop |+>| init_max | | | allowed | tInternal |+>| | | | least-square | |+>| | | | guess of | |+>| | | | constraint | |+>| | | | multipliers. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| constr_mult_ | OT_REAL | 0 | Threshold | CasADi::Ipop |+>| reset_thresh | | | for | tInternal |+>| old | | | resetting | |+>| | | | equality and | |+>| | | | inequality | |+>| | | | multipliers | |+>| | | | after | |+>| | | | restoration | |+>| | | | phase. (see | |+>| | | | IPOPT docume | |+>| | | | ntation) | |+>+--------------+--------------+--------------+--------------+--------------++>| constr_viol_ | OT_REAL | 0.000 | Desired | CasADi::Ipop |+>| tol | | | threshold | tInternal |+>| | | | for the | |+>| | | | constraint | |+>| | | | violation. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| constraint_v | OT_STRING | 1-norm | Norm to be | CasADi::Ipop |+>| iolation_nor | | | used for the | tInternal |+>| m_type | | | constraint | |+>| | | | violation in | |+>| | | | the line | |+>| | | | search. (see | |+>| | | | IPOPT docume | |+>| | | | ntation) | |+>+--------------+--------------+--------------+--------------+--------------++>| corrector_co | OT_REAL | 1 | Complementar | CasADi::Ipop |+>| mpl_avrg_red | | | ity | tInternal |+>| _fact | | | tolerance | |+>| | | | factor for | |+>| | | | accepting | |+>| | | | corrector | |+>| | | | step (unsupp | |+>| | | | orted!). | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| corrector_ty | OT_STRING | none | The type of | CasADi::Ipop |+>| pe | | | corrector | tInternal |+>| | | | steps that | |+>| | | | should be | |+>| | | | taken (unsup | |+>| | | | ported!). | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| delta | OT_REAL | 1 | Multiplier | CasADi::Ipop |+>| | | | for | tInternal |+>| | | | constraint | |+>| | | | violation in | |+>| | | | the | |+>| | | | switching | |+>| | | | rule. (see | |+>| | | | IPOPT docume | |+>| | | | ntation) | |+>+--------------+--------------+--------------+--------------+--------------++>| delta_y_max | OT_REAL | 1.000e+12 | a parameter | CasADi::Ipop |+>| | | | used to | tInternal |+>| | | | check if the | |+>| | | | fast | |+>| | | | direction | |+>| | | | can be used | |+>| | | | asthe line | |+>| | | | search | |+>| | | | direction | |+>| | | | (for Chen- | |+>| | | | Goldfarb | |+>| | | | line | |+>| | | | search). | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| dependency_d | OT_STRING | no | Indicates if | CasADi::Ipop |+>| etection_wit | | | the right | tInternal |+>| h_rhs | | | hand sides | |+>| | | | of the | |+>| | | | constraints | |+>| | | | should be | |+>| | | | considered | |+>| | | | during | |+>| | | | dependency | |+>| | | | detection | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| dependency_d | OT_STRING | none | Indicates | CasADi::Ipop |+>| etector | | | which linear | tInternal |+>| | | | solver | |+>| | | | should be | |+>| | | | used to | |+>| | | | detect | |+>| | | | linearly | |+>| | | | dependent | |+>| | | | equality | |+>| | | | constraints. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| derivative_t | OT_STRING | none | Enable | CasADi::Ipop |+>| est | | | derivative | tInternal |+>| | | | checker (see | |+>| | | | IPOPT docume | |+>| | | | ntation) | |+>+--------------+--------------+--------------+--------------+--------------++>| derivative_t | OT_INTEGER | -2 | Index of | CasADi::Ipop |+>| est_first_in | | | first | tInternal |+>| dex | | | quantity to | |+>| | | | be checked | |+>| | | | by | |+>| | | | derivative | |+>| | | | checker (see | |+>| | | | IPOPT docume | |+>| | | | ntation) | |+>+--------------+--------------+--------------+--------------+--------------++>| derivative_t | OT_REAL | 0.000 | Size of the | CasADi::Ipop |+>| est_perturba | | | finite | tInternal |+>| tion | | | difference | |+>| | | | perturbation | |+>| | | | in | |+>| | | | derivative | |+>| | | | test. (see | |+>| | | | IPOPT docume | |+>| | | | ntation) | |+>+--------------+--------------+--------------+--------------+--------------++>| derivative_t | OT_STRING | no | Indicates | CasADi::Ipop |+>| est_print_al | | | whether | tInternal |+>| l | | | information | |+>| | | | for all | |+>| | | | estimated | |+>| | | | derivatives | |+>| | | | should be | |+>| | | | printed. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| derivative_t | OT_REAL | 0.000 | Threshold | CasADi::Ipop |+>| est_tol | | | for | tInternal |+>| | | | indicating | |+>| | | | wrong | |+>| | | | derivative. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| diverging_it | OT_REAL | 1.000e+20 | Threshold | CasADi::Ipop |+>| erates_tol | | | for maximal | tInternal |+>| | | | value of | |+>| | | | primal | |+>| | | | iterates. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| dual_inf_tol | OT_REAL | 1 | Desired | CasADi::Ipop |+>| | | | threshold | tInternal |+>| | | | for the dual | |+>| | | | infeasibilit | |+>| | | | y. (see | |+>| | | | IPOPT docume | |+>| | | | ntation) | |+>+--------------+--------------+--------------+--------------+--------------++>| epsilon_c | OT_REAL | 0.010 | LIFENG | CasADi::Ipop |+>| | | | WRITES THIS. | tInternal |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| eta_min | OT_REAL | 10 | LIFENG | CasADi::Ipop |+>| | | | WRITES THIS. | tInternal |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| eta_penalty | OT_REAL | 0.000 | Relaxation | CasADi::Ipop |+>| | | | factor in | tInternal |+>| | | | the Armijo | |+>| | | | condition | |+>| | | | for the | |+>| | | | penalty | |+>| | | | function. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| eta_phi | OT_REAL | 0.000 | Relaxation | CasADi::Ipop |+>| | | | factor in | tInternal |+>| | | | the Armijo | |+>| | | | condition. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| evaluate_ori | OT_STRING | yes | Determines | CasADi::Ipop |+>| g_obj_at_res | | | if the | tInternal |+>| to_trial | | | original | |+>| | | | objective | |+>| | | | function | |+>| | | | should be | |+>| | | | evaluated at | |+>| | | | restoration | |+>| | | | phase trial | |+>| | | | points. (see | |+>| | | | IPOPT docume | |+>| | | | ntation) | |+>+--------------+--------------+--------------+--------------+--------------++>| expand | OT_BOOLEAN | false | Expand the | CasADi::NLPS |+>| | | | NLP function | olverInterna |+>| | | | in terms of | l |+>| | | | scalar | |+>| | | | operations, | |+>| | | | i.e. MX-> SX | |+>+--------------+--------------+--------------+--------------+--------------++>| expand_f | OT_BOOLEAN | GenericType( | Expand the | CasADi::NLPS |+>| | | ) | objective | olverInterna |+>| | | | function in | l |+>| | | | terms of | |+>| | | | scalar | |+>| | | | operations, | |+>| | | | i.e. MX-> SX | |+>| | | | . | |+>| | | | Deprecated, | |+>| | | | use "expand" | |+>| | | | instead. | |+>+--------------+--------------+--------------+--------------+--------------++>| expand_g | OT_BOOLEAN | GenericType( | Expand the | CasADi::NLPS |+>| | | ) | constraint | olverInterna |+>| | | | function in | l |+>| | | | terms of | |+>| | | | scalar | |+>| | | | operations, | |+>| | | | i.e. MX-> SX | |+>| | | | . | |+>| | | | Deprecated, | |+>| | | | use "expand" | |+>| | | | instead. | |+>+--------------+--------------+--------------+--------------+--------------++>| expect_infea | OT_STRING | no | Enable | CasADi::Ipop |+>| sible_proble | | | heuristics | tInternal |+>| m | | | to quickly | |+>| | | | detect an | |+>| | | | infeasible | |+>| | | | problem. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| expect_infea | OT_REAL | 0.001 | Threshold | CasADi::Ipop |+>| sible_proble | | | for | tInternal |+>| m_ctol | | | disabling "e | |+>| | | | xpect_infeas | |+>| | | | ible_problem | |+>| | | | " option. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| expect_infea | OT_REAL | 100000000 | Multiplier | CasADi::Ipop |+>| sible_proble | | | threshold | tInternal |+>| m_ytol | | | for | |+>| | | | activating " | |+>| | | | expect_infea | |+>| | | | sible_proble | |+>| | | | m" option. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| fast_des_fac | OT_REAL | 0.100 | a parameter | CasADi::Ipop |+>| t | | | used to | tInternal |+>| | | | check if the | |+>| | | | fast | |+>| | | | direction | |+>| | | | can be used | |+>| | | | asthe line | |+>| | | | search | |+>| | | | direction | |+>| | | | (for Chen- | |+>| | | | Goldfarb | |+>| | | | line | |+>| | | | search). | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| fast_step_co | OT_STRING | no | Indicates if | CasADi::Ipop |+>| mputation | | | the linear | tInternal |+>| | | | system | |+>| | | | should be | |+>| | | | solved | |+>| | | | quickly. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| file_print_l | OT_INTEGER | 5 | Verbosity | CasADi::Ipop |+>| evel | | | level for | tInternal |+>| | | | output file. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| filter_margi | OT_REAL | 0.000 | Factor | CasADi::Ipop |+>| n_fact | | | determining | tInternal |+>| | | | width of | |+>| | | | margin for | |+>| | | | obj-constr- | |+>| | | | filter | |+>| | | | adaptive glo | |+>| | | | balization | |+>| | | | strategy. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| filter_max_m | OT_REAL | 1 | Maximum | CasADi::Ipop |+>| argin | | | width of | tInternal |+>| | | | margin in | |+>| | | | obj-constr- | |+>| | | | filter | |+>| | | | adaptive glo | |+>| | | | balization | |+>| | | | strategy. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| filter_reset | OT_INTEGER | 5 | Number of | CasADi::Ipop |+>| _trigger | | | iterations | tInternal |+>| | | | that trigger | |+>| | | | the filter | |+>| | | | reset. (see | |+>| | | | IPOPT docume | |+>| | | | ntation) | |+>+--------------+--------------+--------------+--------------+--------------++>| findiff_pert | OT_REAL | 0.000 | Size of the | CasADi::Ipop |+>| urbation | | | finite | tInternal |+>| | | | difference | |+>| | | | perturbation | |+>| | | | for | |+>| | | | derivative a | |+>| | | | pproximation | |+>| | | | . (see IPOPT | |+>| | | | documentatio | |+>| | | | n) | |+>+--------------+--------------+--------------+--------------+--------------++>| first_hessia | OT_REAL | 0.000 | Size of | CasADi::Ipop |+>| n_perturbati | | | first x-s | tInternal |+>| on | | | perturbation | |+>| | | | tried. (see | |+>| | | | IPOPT docume | |+>| | | | ntation) | |+>+--------------+--------------+--------------+--------------+--------------++>| fixed_mu_ora | OT_STRING | average_comp | Oracle for | CasADi::Ipop |+>| cle | | l | the barrier | tInternal |+>| | | | parameter | |+>| | | | when | |+>| | | | switching to | |+>| | | | fixed mode. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| fixed_variab | OT_STRING | make_paramet | Determines | CasADi::Ipop |+>| le_treatment | | er | how fixed | tInternal |+>| | | | variables | |+>| | | | should be | |+>| | | | handled. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| gamma_hat | OT_REAL | 0.040 | LIFENG | CasADi::Ipop |+>| | | | WRITES THIS. | tInternal |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| gamma_phi | OT_REAL | 0.000 | Relaxation | CasADi::Ipop |+>| | | | factor in | tInternal |+>| | | | the filter | |+>| | | | margin for | |+>| | | | the barrier | |+>| | | | function. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| gamma_theta | OT_REAL | 0.000 | Relaxation | CasADi::Ipop |+>| | | | factor in | tInternal |+>| | | | the filter | |+>| | | | margin for | |+>| | | | the | |+>| | | | constraint | |+>| | | | violation. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| gamma_tilde | OT_REAL | 4 | LIFENG | CasADi::Ipop |+>| | | | WRITES THIS. | tInternal |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| gather_stats | OT_BOOLEAN | false | Flag to | CasADi::FXIn |+>| | | | indicate | ternal |+>| | | | wether | |+>| | | | statistics | |+>| | | | must be | |+>| | | | gathered | |+>+--------------+--------------+--------------+--------------+--------------++>| gauss_newton | OT_BOOLEAN | GenericType( | Deprecated | CasADi::NLPS |+>| | | ) | option. Use | olverInterna |+>| | | | Gauss Newton | l |+>| | | | Hessian appr | |+>| | | | oximation | |+>+--------------+--------------+--------------+--------------+--------------++>| generate_gra | OT_BOOLEAN | GenericType( | Deprecated | CasADi::NLPS |+>| dient | | ) | option. | olverInterna |+>| | | | Generate a | l |+>| | | | function for | |+>| | | | calculating | |+>| | | | the gradient | |+>| | | | of the | |+>| | | | objective. | |+>+--------------+--------------+--------------+--------------+--------------++>| generate_hes | OT_BOOLEAN | GenericType( | Deprecated | CasADi::NLPS |+>| sian | | ) | option. | olverInterna |+>| | | | Generate an | l |+>| | | | exact | |+>| | | | Hessian of | |+>| | | | the | |+>| | | | Lagrangian | |+>| | | | if not | |+>| | | | supplied. | |+>+--------------+--------------+--------------+--------------+--------------++>| generate_jac | OT_BOOLEAN | GenericType( | Deprecated | CasADi::NLPS |+>| obian | | ) | option. | olverInterna |+>| | | | Generate an | l |+>| | | | exact | |+>| | | | Jacobian of | |+>| | | | the | |+>| | | | constraints | |+>| | | | if not | |+>| | | | supplied. | |+>+--------------+--------------+--------------+--------------+--------------++>| grad_f | OT_FX | GenericType( | Function for | CasADi::NLPS |+>| | | ) | calculating | olverInterna |+>| | | | the gradient | l |+>| | | | of the | |+>| | | | objective (a | |+>| | | | utogenerated | |+>| | | | by default) | |+>+--------------+--------------+--------------+--------------+--------------++>| grad_lag | OT_FX | GenericType( | Function for | CasADi::NLPS |+>| | | ) | calculating | olverInterna |+>| | | | the gradient | l |+>| | | | of the | |+>| | | | Lagrangian ( | |+>| | | | autogenerate | |+>| | | | d by | |+>| | | | default) | |+>+--------------+--------------+--------------+--------------+--------------++>| hess_lag | OT_FX | GenericType( | Function for | CasADi::NLPS |+>| | | ) | calculating | olverInterna |+>| | | | the Hessian | l |+>| | | | of the | |+>| | | | Lagrangian ( | |+>| | | | autogenerate | |+>| | | | d by | |+>| | | | default) | |+>+--------------+--------------+--------------+--------------+--------------++>| hessian_appr | OT_STRING | exact | Indicates | CasADi::Ipop |+>| oximation | | | what Hessian | tInternal |+>| | | | information | |+>| | | | is to be | |+>| | | | used. (see | |+>| | | | IPOPT docume | |+>| | | | ntation) | |+>+--------------+--------------+--------------+--------------+--------------++>| hessian_appr | OT_STRING | nonlinear- | Indicates in | CasADi::Ipop |+>| oximation_sp | | variables | which | tInternal |+>| ace | | | subspace the | |+>| | | | Hessian | |+>| | | | information | |+>| | | | is to be app | |+>| | | | roximated. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| hessian_cons | OT_STRING | no | Indicates | CasADi::Ipop |+>| tant | | | whether the | tInternal |+>| | | | problem is a | |+>| | | | quadratic | |+>| | | | problem (see | |+>| | | | IPOPT docume | |+>| | | | ntation) | |+>+--------------+--------------+--------------+--------------+--------------++>| honor_origin | OT_STRING | yes | Indicates | CasADi::Ipop |+>| al_bounds | | | whether | tInternal |+>| | | | final points | |+>| | | | should be | |+>| | | | projected | |+>| | | | into | |+>| | | | original | |+>| | | | bounds. (see | |+>| | | | IPOPT docume | |+>| | | | ntation) | |+>+--------------+--------------+--------------+--------------+--------------++>| ignore_check | OT_BOOLEAN | false | If set to | CasADi::NLPS |+>| _vec | | | true, the | olverInterna |+>| | | | input shape | l |+>| | | | of F will | |+>| | | | not be | |+>| | | | checked. | |+>+--------------+--------------+--------------+--------------+--------------++>| inf_pr_outpu | OT_STRING | original | Determines | CasADi::Ipop |+>| t | | | what value | tInternal |+>| | | | is printed | |+>| | | | in the | |+>| | | | "inf_pr" | |+>| | | | output | |+>| | | | column. (see | |+>| | | | IPOPT docume | |+>| | | | ntation) | |+>+--------------+--------------+--------------+--------------+--------------++>| inputs_check | OT_BOOLEAN | true | Throw | CasADi::FXIn |+>| | | | exceptions | ternal |+>| | | | when the | |+>| | | | numerical | |+>| | | | values of | |+>| | | | the inputs | |+>| | | | don't make | |+>| | | | sense | |+>+--------------+--------------+--------------+--------------+--------------++>| iteration_ca | OT_CALLBACK | GenericType( | A function | CasADi::NLPS |+>| llback | | ) | that will be | olverInterna |+>| | | | called at | l |+>| | | | each | |+>| | | | iteration | |+>| | | | with the | |+>| | | | solver as | |+>| | | | input. Check | |+>| | | | documentatio | |+>| | | | n of | |+>| | | | Callback . | |+>+--------------+--------------+--------------+--------------+--------------++>| iteration_ca | OT_BOOLEAN | false | If set to | CasADi::NLPS |+>| llback_ignor | | | true, errors | olverInterna |+>| e_errors | | | thrown by it | l |+>| | | | eration_call | |+>| | | | back will be | |+>| | | | ignored. | |+>+--------------+--------------+--------------+--------------+--------------++>| iteration_ca | OT_INTEGER | 1 | Only call | CasADi::NLPS |+>| llback_step | | | the callback | olverInterna |+>| | | | function | l |+>| | | | every few | |+>| | | | iterations. | |+>+--------------+--------------+--------------+--------------+--------------++>| jac_c_consta | OT_STRING | no | Indicates | CasADi::Ipop |+>| nt | | | whether all | tInternal |+>| | | | equality | |+>| | | | constraints | |+>| | | | are linear | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| jac_d_consta | OT_STRING | no | Indicates | CasADi::Ipop |+>| nt | | | whether all | tInternal |+>| | | | inequality | |+>| | | | constraints | |+>| | | | are linear | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| jac_g | OT_FX | GenericType( | Function for | CasADi::NLPS |+>| | | ) | calculating | olverInterna |+>| | | | the Jacobian | l |+>| | | | of the | |+>| | | | constraints | |+>| | | | (autogenerat | |+>| | | | ed by | |+>| | | | default) | |+>+--------------+--------------+--------------+--------------+--------------++>| jacobian_app | OT_STRING | exact | Specifies | CasADi::Ipop |+>| roximation | | | technique to | tInternal |+>| | | | compute | |+>| | | | constraint | |+>| | | | Jacobian | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| jacobian_gen | OT_JACOBIANG | GenericType( | Function | CasADi::FXIn |+>| erator | ENERATOR | ) | that returns | ternal |+>| | | | a Jacobian | |+>| | | | function | |+>| | | | given a set | |+>| | | | of desired | |+>| | | | Jacobian | |+>| | | | blocks, | |+>| | | | overrides | |+>| | | | internal | |+>| | | | routines. | |+>| | | | Check docume | |+>| | | | ntation of J | |+>| | | | acobianGener | |+>| | | | ator . | |+>+--------------+--------------+--------------+--------------+--------------++>| jacobian_reg | OT_REAL | 0.250 | Exponent for | CasADi::Ipop |+>| ularization_ | | | mu in the re | tInternal |+>| exponent | | | gularization | |+>| | | | for rank- | |+>| | | | deficient | |+>| | | | constraint | |+>| | | | Jacobians. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| jacobian_reg | OT_REAL | 0.000 | Size of the | CasADi::Ipop |+>| ularization_ | | | regularizati | tInternal |+>| value | | | on for rank- | |+>| | | | deficient | |+>| | | | constraint | |+>| | | | Jacobians. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| kappa_d | OT_REAL | 0.000 | Weight for | CasADi::Ipop |+>| | | | linear | tInternal |+>| | | | damping term | |+>| | | | (to handle | |+>| | | | one-sided | |+>| | | | bounds). | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| kappa_sigma | OT_REAL | 1.000e+10 | Factor | CasADi::Ipop |+>| | | | limiting the | tInternal |+>| | | | deviation of | |+>| | | | dual | |+>| | | | variables | |+>| | | | from primal | |+>| | | | estimates. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| kappa_soc | OT_REAL | 0.990 | Factor in | CasADi::Ipop |+>| | | | the | tInternal |+>| | | | sufficient | |+>| | | | reduction | |+>| | | | rule for | |+>| | | | second order | |+>| | | | correction. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| kappa_x_dis | OT_REAL | 100 | a parameter | CasADi::Ipop |+>| | | | used to | tInternal |+>| | | | check if the | |+>| | | | fast | |+>| | | | direction | |+>| | | | can be used | |+>| | | | asthe line | |+>| | | | search | |+>| | | | direction | |+>| | | | (for Chen- | |+>| | | | Goldfarb | |+>| | | | line | |+>| | | | search). | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| kappa_y_dis | OT_REAL | 10000 | a parameter | CasADi::Ipop |+>| | | | used to | tInternal |+>| | | | check if the | |+>| | | | fast | |+>| | | | direction | |+>| | | | can be used | |+>| | | | asthe line | |+>| | | | search | |+>| | | | direction | |+>| | | | (for Chen- | |+>| | | | Goldfarb | |+>| | | | line | |+>| | | | search). | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| least_square | OT_STRING | no | Least square | CasADi::Ipop |+>| _init_duals | | | initializati | tInternal |+>| | | | on of all | |+>| | | | dual | |+>| | | | variables | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| least_square | OT_STRING | no | Least square | CasADi::Ipop |+>| _init_primal | | | initializati | tInternal |+>| | | | on of the | |+>| | | | primal | |+>| | | | variables | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| limited_memo | OT_STRING | sherman- | Strategy for | CasADi::Ipop |+>| ry_aug_solve | | morrison | solving the | tInternal |+>| r | | | augmented | |+>| | | | system for | |+>| | | | low-rank | |+>| | | | Hessian. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| limited_memo | OT_REAL | 1 | Value for B0 | CasADi::Ipop |+>| ry_init_val | | | in low-rank | tInternal |+>| | | | update. (see | |+>| | | | IPOPT docume | |+>| | | | ntation) | |+>+--------------+--------------+--------------+--------------+--------------++>| limited_memo | OT_REAL | 100000000 | Upper bound | CasADi::Ipop |+>| ry_init_val_ | | | on value for | tInternal |+>| max | | | B0 in low- | |+>| | | | rank update. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| limited_memo | OT_REAL | 0.000 | Lower bound | CasADi::Ipop |+>| ry_init_val_ | | | on value for | tInternal |+>| min | | | B0 in low- | |+>| | | | rank update. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| limited_memo | OT_STRING | scalar1 | Initializati | CasADi::Ipop |+>| ry_initializ | | | on strategy | tInternal |+>| ation | | | for the | |+>| | | | limited | |+>| | | | memory | |+>| | | | quasi-Newton | |+>| | | | approximatio | |+>| | | | n. (see | |+>| | | | IPOPT docume | |+>| | | | ntation) | |+>+--------------+--------------+--------------+--------------+--------------++>| limited_memo | OT_INTEGER | 6 | Maximum size | CasADi::Ipop |+>| ry_max_histo | | | of the | tInternal |+>| ry | | | history for | |+>| | | | the limited | |+>| | | | quasi-Newton | |+>| | | | Hessian appr | |+>| | | | oximation. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| limited_memo | OT_INTEGER | 2 | Threshold | CasADi::Ipop |+>| ry_max_skipp | | | for | tInternal |+>| ing | | | successive | |+>| | | | iterations | |+>| | | | where update | |+>| | | | is skipped. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| limited_memo | OT_STRING | no | Determines | CasADi::Ipop |+>| ry_special_f | | | if the | tInternal |+>| or_resto | | | quasi-Newton | |+>| | | | updates | |+>| | | | should be | |+>| | | | special | |+>| | | | during the | |+>| | | | restoration | |+>| | | | phase. (see | |+>| | | | IPOPT docume | |+>| | | | ntation) | |+>+--------------+--------------+--------------+--------------+--------------++>| limited_memo | OT_STRING | bfgs | Quasi-Newton | CasADi::Ipop |+>| ry_update_ty | | | update | tInternal |+>| pe | | | formula for | |+>| | | | the limited | |+>| | | | memory appro | |+>| | | | ximation. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| line_search_ | OT_STRING | filter | Globalizatio | CasADi::Ipop |+>| method | | | n method | tInternal |+>| | | | used in | |+>| | | | backtracking | |+>| | | | line search | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| linear_scali | OT_STRING | yes | Flag | CasADi::Ipop |+>| ng_on_demand | | | indicating | tInternal |+>| | | | that linear | |+>| | | | scaling is | |+>| | | | only done if | |+>| | | | it seems | |+>| | | | required. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| linear_solve | OT_STRING | ma27 | Linear | CasADi::Ipop |+>| r | | | solver used | tInternal |+>| | | | for step com | |+>| | | | putations. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| linear_syste | OT_STRING | mc19 | Method for | CasADi::Ipop |+>| m_scaling | | | scaling the | tInternal |+>| | | | linear | |+>| | | | system. (see | |+>| | | | IPOPT docume | |+>| | | | ntation) | |+>+--------------+--------------+--------------+--------------+--------------++>| ma27_ignore_ | OT_STRING | no | Enables | CasADi::Ipop |+>| singularity | | | MA27's | tInternal |+>| | | | ability to | |+>| | | | solve a | |+>| | | | linear | |+>| | | | system even | |+>| | | | if the | |+>| | | | matrix is | |+>| | | | singular. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| ma27_la_init | OT_REAL | 5 | Real | CasADi::Ipop |+>| _factor | | | workspace | tInternal |+>| | | | memory for | |+>| | | | MA27. (see | |+>| | | | IPOPT docume | |+>| | | | ntation) | |+>+--------------+--------------+--------------+--------------+--------------++>| ma27_liw_ini | OT_REAL | 5 | Integer | CasADi::Ipop |+>| t_factor | | | workspace | tInternal |+>| | | | memory for | |+>| | | | MA27. (see | |+>| | | | IPOPT docume | |+>| | | | ntation) | |+>+--------------+--------------+--------------+--------------+--------------++>| ma27_meminc_ | OT_REAL | 10 | Increment | CasADi::Ipop |+>| factor | | | factor for | tInternal |+>| | | | workspace | |+>| | | | size for | |+>| | | | MA27. (see | |+>| | | | IPOPT docume | |+>| | | | ntation) | |+>+--------------+--------------+--------------+--------------+--------------++>| ma27_pivtol | OT_REAL | 0.000 | Pivot | CasADi::Ipop |+>| | | | tolerance | tInternal |+>| | | | for the | |+>| | | | linear | |+>| | | | solver MA27. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| ma27_pivtolm | OT_REAL | 0.000 | Maximum | CasADi::Ipop |+>| ax | | | pivot | tInternal |+>| | | | tolerance | |+>| | | | for the | |+>| | | | linear | |+>| | | | solver MA27. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| ma27_skip_in | OT_STRING | no | Always | CasADi::Ipop |+>| ertia_check | | | pretend | tInternal |+>| | | | inertia is | |+>| | | | correct. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| ma28_pivtol | OT_REAL | 0.010 | Pivot | CasADi::Ipop |+>| | | | tolerance | tInternal |+>| | | | for linear | |+>| | | | solver MA28. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| ma57_automat | OT_STRING | yes | Controls | CasADi::Ipop |+>| ic_scaling | | | MA57 | tInternal |+>| | | | automatic | |+>| | | | scaling (see | |+>| | | | IPOPT docume | |+>| | | | ntation) | |+>+--------------+--------------+--------------+--------------+--------------++>| ma57_block_s | OT_INTEGER | 16 | Controls | CasADi::Ipop |+>| ize | | | block size | tInternal |+>| | | | used by | |+>| | | | Level 3 BLAS | |+>| | | | in MA57BD | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| ma57_node_am | OT_INTEGER | 16 | Node | CasADi::Ipop |+>| algamation | | | amalgamation | tInternal |+>| | | | parameter | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| ma57_pivot_o | OT_INTEGER | 5 | Controls | CasADi::Ipop |+>| rder | | | pivot order | tInternal |+>| | | | in MA57 (see | |+>| | | | IPOPT docume | |+>| | | | ntation) | |+>+--------------+--------------+--------------+--------------+--------------++>| ma57_pivtol | OT_REAL | 0.000 | Pivot | CasADi::Ipop |+>| | | | tolerance | tInternal |+>| | | | for the | |+>| | | | linear | |+>| | | | solver MA57. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| ma57_pivtolm | OT_REAL | 0.000 | Maximum | CasADi::Ipop |+>| ax | | | pivot | tInternal |+>| | | | tolerance | |+>| | | | for the | |+>| | | | linear | |+>| | | | solver MA57. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| ma57_pre_all | OT_REAL | 1.050 | Safety | CasADi::Ipop |+>| oc | | | factor for | tInternal |+>| | | | work space | |+>| | | | memory | |+>| | | | allocation | |+>| | | | for the | |+>| | | | linear | |+>| | | | solver MA57. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| ma57_small_p | OT_INTEGER | 0 | If set to 1, | CasADi::Ipop |+>| ivot_flag | | | then when | tInternal |+>| | | | small | |+>| | | | entries | |+>| | | | defined by | |+>| | | | CNTL(2) are | |+>| | | | detected | |+>| | | | they are | |+>| | | | removed and | |+>| | | | the correspo | |+>| | | | nding pivots | |+>| | | | placed at | |+>| | | | the end of | |+>| | | | the factoriz | |+>| | | | ation. This | |+>| | | | can be | |+>| | | | particularly | |+>| | | | efficient if | |+>| | | | the matrix | |+>| | | | is highly | |+>| | | | rank | |+>| | | | deficient. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| ma86_nemin | OT_INTEGER | 32 | Node | CasADi::Ipop |+>| | | | Amalgamation | tInternal |+>| | | | parameter | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| ma86_print_l | OT_INTEGER | 0 | Debug | CasADi::Ipop |+>| evel | | | printing | tInternal |+>| | | | level for | |+>| | | | the linear | |+>| | | | solver MA86 | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| ma86_small | OT_REAL | 0.000 | Zero Pivot | CasADi::Ipop |+>| | | | Threshold | tInternal |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| ma86_static | OT_REAL | 0 | Static | CasADi::Ipop |+>| | | | Pivoting | tInternal |+>| | | | Threshold | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| ma86_u | OT_REAL | 0.000 | Pivoting | CasADi::Ipop |+>| | | | Threshold | tInternal |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| ma86_umax | OT_REAL | 0.000 | Maximum | CasADi::Ipop |+>| | | | Pivoting | tInternal |+>| | | | Threshold | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| magic_steps | OT_STRING | no | Enables | CasADi::Ipop |+>| | | | magic steps. | tInternal |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| max_cpu_time | OT_REAL | 1000000 | Maximum | CasADi::Ipop |+>| | | | number of | tInternal |+>| | | | CPU seconds. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| max_filter_r | OT_INTEGER | 5 | Maximal | CasADi::Ipop |+>| esets | | | allowed | tInternal |+>| | | | number of | |+>| | | | filter | |+>| | | | resets (see | |+>| | | | IPOPT docume | |+>| | | | ntation) | |+>+--------------+--------------+--------------+--------------+--------------++>| max_hessian_ | OT_REAL | 1.000e+20 | Maximum | CasADi::Ipop |+>| perturbation | | | value of reg | tInternal |+>| | | | ularization | |+>| | | | parameter | |+>| | | | for handling | |+>| | | | negative | |+>| | | | curvature. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| max_iter | OT_INTEGER | 3000 | Maximum | CasADi::Ipop |+>| | | | number of | tInternal |+>| | | | iterations. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| max_number_o | OT_INTEGER | optimized_nu | Allow "numbe | CasADi::FXIn |+>| f_adj_dir | | m_dir | r_of_adj_dir | ternal |+>| | | | " to grow | |+>| | | | until it | |+>| | | | reaches this | |+>| | | | number | |+>+--------------+--------------+--------------+--------------+--------------++>| max_number_o | OT_INTEGER | optimized_nu | Allow "numbe | CasADi::FXIn |+>| f_fwd_dir | | m_dir | r_of_fwd_dir | ternal |+>| | | | " to grow | |+>| | | | until it | |+>| | | | reaches this | |+>| | | | number | |+>+--------------+--------------+--------------+--------------+--------------++>| max_refineme | OT_INTEGER | 10 | Maximum | CasADi::Ipop |+>| nt_steps | | | number of | tInternal |+>| | | | iterative | |+>| | | | refinement | |+>| | | | steps per | |+>| | | | linear | |+>| | | | system | |+>| | | | solve. (see | |+>| | | | IPOPT docume | |+>| | | | ntation) | |+>+--------------+--------------+--------------+--------------+--------------++>| max_resto_it | OT_INTEGER | 3000000 | Maximum | CasADi::Ipop |+>| er | | | number of | tInternal |+>| | | | successive | |+>| | | | iterations | |+>| | | | in | |+>| | | | restoration | |+>| | | | phase. (see | |+>| | | | IPOPT docume | |+>| | | | ntation) | |+>+--------------+--------------+--------------+--------------+--------------++>| max_soc | OT_INTEGER | 4 | Maximum | CasADi::Ipop |+>| | | | number of | tInternal |+>| | | | second order | |+>| | | | correction | |+>| | | | trial steps | |+>| | | | at each | |+>| | | | iteration. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| max_soft_res | OT_INTEGER | 10 | Maximum | CasADi::Ipop |+>| to_iters | | | number of | tInternal |+>| | | | iterations | |+>| | | | performed | |+>| | | | successively | |+>| | | | in soft | |+>| | | | restoration | |+>| | | | phase. (see | |+>| | | | IPOPT docume | |+>| | | | ntation) | |+>+--------------+--------------+--------------+--------------+--------------++>| mehrotra_alg | OT_STRING | no | Indicates if | CasADi::Ipop |+>| orithm | | | we want to | tInternal |+>| | | | do | |+>| | | | Mehrotra's | |+>| | | | algorithm. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| min_alpha_pr | OT_REAL | 0.000 | LIFENG | CasADi::Ipop |+>| imal | | | WRITES THIS. | tInternal |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| min_hessian_ | OT_REAL | 0.000 | Smallest | CasADi::Ipop |+>| perturbation | | | perturbation | tInternal |+>| | | | of the | |+>| | | | Hessian | |+>| | | | block. (see | |+>| | | | IPOPT docume | |+>| | | | ntation) | |+>+--------------+--------------+--------------+--------------+--------------++>| min_refineme | OT_INTEGER | 1 | Minimum | CasADi::Ipop |+>| nt_steps | | | number of | tInternal |+>| | | | iterative | |+>| | | | refinement | |+>| | | | steps per | |+>| | | | linear | |+>| | | | system | |+>| | | | solve. (see | |+>| | | | IPOPT docume | |+>| | | | ntation) | |+>+--------------+--------------+--------------+--------------+--------------++>| monitor | OT_STRINGVEC | GenericType( | Monitors to | CasADi::FXIn |+>| | TOR | ) | be activated | ternal Cas |+>| | | | (inputs|outp | ADi::IpoptIn |+>| | | | uts) (eval_ | ternal |+>| | | | f|eval_g|eva | |+>| | | | l_jac_g|eval | |+>| | | | _grad_f) | |+>+--------------+--------------+--------------+--------------+--------------++>| mu_allow_fas | OT_STRING | yes | Allow | CasADi::Ipop |+>| t_monotone_d | | | skipping of | tInternal |+>| ecrease | | | barrier | |+>| | | | problem if | |+>| | | | barrier test | |+>| | | | is already | |+>| | | | met. (see | |+>| | | | IPOPT docume | |+>| | | | ntation) | |+>+--------------+--------------+--------------+--------------+--------------++>| mu_init | OT_REAL | 0.100 | Initial | CasADi::Ipop |+>| | | | value for | tInternal |+>| | | | the barrier | |+>| | | | parameter. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| mu_linear_de | OT_REAL | 0.200 | Determines | CasADi::Ipop |+>| crease_facto | | | linear | tInternal |+>| r | | | decrease | |+>| | | | rate of | |+>| | | | barrier | |+>| | | | parameter. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| mu_max | OT_REAL | 100000 | Maximum | CasADi::Ipop |+>| | | | value for | tInternal |+>| | | | barrier | |+>| | | | parameter. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| mu_max_fact | OT_REAL | 1000 | Factor for i | CasADi::Ipop |+>| | | | nitializatio | tInternal |+>| | | | n of maximum | |+>| | | | value for | |+>| | | | barrier | |+>| | | | parameter. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| mu_min | OT_REAL | 0.000 | Minimum | CasADi::Ipop |+>| | | | value for | tInternal |+>| | | | barrier | |+>| | | | parameter. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| mu_oracle | OT_STRING | quality- | Oracle for a | CasADi::Ipop |+>| | | function | new barrier | tInternal |+>| | | | parameter in | |+>| | | | the adaptive | |+>| | | | strategy. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| mu_strategy | OT_STRING | monotone | Update | CasADi::Ipop |+>| | | | strategy for | tInternal |+>| | | | barrier | |+>| | | | parameter. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| mu_superline | OT_REAL | 1.500 | Determines | CasADi::Ipop |+>| ar_decrease_ | | | superlinear | tInternal |+>| power | | | decrease | |+>| | | | rate of | |+>| | | | barrier | |+>| | | | parameter. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| mu_target | OT_REAL | 0 | Desired | CasADi::Ipop |+>| | | | value of com | tInternal |+>| | | | plementarity | |+>| | | | . (see IPOPT | |+>| | | | documentatio | |+>| | | | n) | |+>+--------------+--------------+--------------+--------------+--------------++>| mult_diverg_ | OT_REAL | 0.000 | tolerance | CasADi::Ipop |+>| feasibility_ | | | for deciding | tInternal |+>| tol | | | if the | |+>| | | | multipliers | |+>| | | | are | |+>| | | | diverging | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| mult_diverg_ | OT_REAL | 100000000 | tolerance | CasADi::Ipop |+>| y_tol | | | for deciding | tInternal |+>| | | | if the | |+>| | | | multipliers | |+>| | | | are | |+>| | | | diverging | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| mumps_dep_to | OT_REAL | -1 | Pivot | CasADi::Ipop |+>| l | | | threshold | tInternal |+>| | | | for | |+>| | | | detection of | |+>| | | | linearly | |+>| | | | dependent | |+>| | | | constraints | |+>| | | | in MUMPS. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| mumps_mem_pe | OT_INTEGER | 1000 | Percentage | CasADi::Ipop |+>| rcent | | | increase in | tInternal |+>| | | | the | |+>| | | | estimated | |+>| | | | working | |+>| | | | space for | |+>| | | | MUMPS. (see | |+>| | | | IPOPT docume | |+>| | | | ntation) | |+>+--------------+--------------+--------------+--------------+--------------++>| mumps_permut | OT_INTEGER | 7 | Controls | CasADi::Ipop |+>| ing_scaling | | | permuting | tInternal |+>| | | | and scaling | |+>| | | | in MUMPS | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| mumps_pivot_ | OT_INTEGER | 7 | Controls | CasADi::Ipop |+>| order | | | pivot order | tInternal |+>| | | | in MUMPS | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| mumps_pivtol | OT_REAL | 0.000 | Pivot | CasADi::Ipop |+>| | | | tolerance | tInternal |+>| | | | for the | |+>| | | | linear | |+>| | | | solver | |+>| | | | MUMPS. (see | |+>| | | | IPOPT docume | |+>| | | | ntation) | |+>+--------------+--------------+--------------+--------------+--------------++>| mumps_pivtol | OT_REAL | 0.100 | Maximum | CasADi::Ipop |+>| max | | | pivot | tInternal |+>| | | | tolerance | |+>| | | | for the | |+>| | | | linear | |+>| | | | solver | |+>| | | | MUMPS. (see | |+>| | | | IPOPT docume | |+>| | | | ntation) | |+>+--------------+--------------+--------------+--------------+--------------++>| mumps_scalin | OT_INTEGER | 77 | Controls | CasADi::Ipop |+>| g | | | scaling in | tInternal |+>| | | | MUMPS (see | |+>| | | | IPOPT docume | |+>| | | | ntation) | |+>+--------------+--------------+--------------+--------------+--------------++>| name | OT_STRING | "unnamed_sha | name of the | CasADi::Opti |+>| | | red_object" | object | onsFunctiona |+>| | | | | lityNode |+>+--------------+--------------+--------------+--------------+--------------++>| neg_curv_tes | OT_REAL | 0 | Tolerance | CasADi::Ipop |+>| t_tol | | | for | tInternal |+>| | | | heuristic to | |+>| | | | ignore wrong | |+>| | | | inertia. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| never_use_fa | OT_STRING | no | Toggle to | CasADi::Ipop |+>| ct_cgpen_dir | | | switch off | tInternal |+>| ection | | | the fast | |+>| | | | Chen- | |+>| | | | Goldfarb | |+>| | | | direction | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| never_use_pi | OT_STRING | no | Toggle to | CasADi::Ipop |+>| ecewise_pena | | | switch off | tInternal |+>| lty_ls | | | the | |+>| | | | piecewise | |+>| | | | penalty | |+>| | | | method (see | |+>| | | | IPOPT docume | |+>| | | | ntation) | |+>+--------------+--------------+--------------+--------------+--------------++>| nlp_lower_bo | OT_REAL | -1.000e+19 | any bound | CasADi::Ipop |+>| und_inf | | | less or | tInternal |+>| | | | equal this | |+>| | | | value will | |+>| | | | be | |+>| | | | considered | |+>| | | | -inf (i.e. | |+>| | | | not lower | |+>| | | | bounded). | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| nlp_scaling_ | OT_REAL | 0 | Target value | CasADi::Ipop |+>| constr_targe | | | for | tInternal |+>| t_gradient | | | constraint | |+>| | | | function | |+>| | | | gradient | |+>| | | | size. (see | |+>| | | | IPOPT docume | |+>| | | | ntation) | |+>+--------------+--------------+--------------+--------------+--------------++>| nlp_scaling_ | OT_REAL | 100 | Maximum | CasADi::Ipop |+>| max_gradient | | | gradient | tInternal |+>| | | | after NLP | |+>| | | | scaling. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| nlp_scaling_ | OT_STRING | gradient- | Select the | CasADi::Ipop |+>| method | | based | technique | tInternal |+>| | | | used for | |+>| | | | scaling the | |+>| | | | NLP. (see | |+>| | | | IPOPT docume | |+>| | | | ntation) | |+>+--------------+--------------+--------------+--------------+--------------++>| nlp_scaling_ | OT_REAL | 0.000 | Minimum | CasADi::Ipop |+>| min_value | | | value of | tInternal |+>| | | | gradient- | |+>| | | | based | |+>| | | | scaling | |+>| | | | values. (see | |+>| | | | IPOPT docume | |+>| | | | ntation) | |+>+--------------+--------------+--------------+--------------+--------------++>| nlp_scaling_ | OT_REAL | 0 | Target value | CasADi::Ipop |+>| obj_target_g | | | for | tInternal |+>| radient | | | objective | |+>| | | | function | |+>| | | | gradient | |+>| | | | size. (see | |+>| | | | IPOPT docume | |+>| | | | ntation) | |+>+--------------+--------------+--------------+--------------+--------------++>| nlp_upper_bo | OT_REAL | 1.000e+19 | any bound | CasADi::Ipop |+>| und_inf | | | greater or | tInternal |+>| | | | this value | |+>| | | | will be | |+>| | | | considered | |+>| | | | +inf (i.e. | |+>| | | | not upper | |+>| | | | bounded). | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| nu_inc | OT_REAL | 0.000 | Increment of | CasADi::Ipop |+>| | | | the penalty | tInternal |+>| | | | parameter. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| nu_init | OT_REAL | 0.000 | Initial | CasADi::Ipop |+>| | | | value of the | tInternal |+>| | | | penalty | |+>| | | | parameter. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| num_linear_v | OT_INTEGER | 0 | Number of | CasADi::Ipop |+>| ariables | | | linear | tInternal |+>| | | | variables | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| number_of_ad | OT_INTEGER | 1 | number of | CasADi::FXIn |+>| j_dir | | | adjoint | ternal |+>| | | | derivatives | |+>| | | | to be | |+>| | | | calculated s | |+>| | | | imultanously | |+>+--------------+--------------+--------------+--------------+--------------++>| number_of_fw | OT_INTEGER | 1 | number of | CasADi::FXIn |+>| d_dir | | | forward | ternal |+>| | | | derivatives | |+>| | | | to be | |+>| | | | calculated s | |+>| | | | imultanously | |+>+--------------+--------------+--------------+--------------+--------------++>| numeric_hess | OT_BOOLEAN | false | Calculate | CasADi::FXIn |+>| ian | | | Hessians | ternal |+>| | | | numerically | |+>| | | | (using | |+>| | | | directional | |+>| | | | derivatives) | |+>| | | | rather than | |+>| | | | with the | |+>| | | | built-in | |+>| | | | method | |+>+--------------+--------------+--------------+--------------+--------------++>| numeric_jaco | OT_BOOLEAN | false | Calculate | CasADi::FXIn |+>| bian | | | Jacobians | ternal |+>| | | | numerically | |+>| | | | (using | |+>| | | | directional | |+>| | | | derivatives) | |+>| | | | rather than | |+>| | | | with the | |+>| | | | built-in | |+>| | | | method | |+>+--------------+--------------+--------------+--------------+--------------++>| obj_max_inc | OT_REAL | 5 | Determines | CasADi::Ipop |+>| | | | the upper | tInternal |+>| | | | bound on the | |+>| | | | acceptable | |+>| | | | increase of | |+>| | | | barrier | |+>| | | | objective | |+>| | | | function. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| obj_scaling_ | OT_REAL | 1 | Scaling | CasADi::Ipop |+>| factor | | | factor for | tInternal |+>| | | | the | |+>| | | | objective | |+>| | | | function. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| option_file_ | OT_STRING | | File name of | CasADi::Ipop |+>| name | | | options file | tInternal |+>| | | | (to | |+>| | | | overwrite | |+>| | | | default). | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| output_file | OT_STRING | | File name of | CasADi::Ipop |+>| | | | desired | tInternal |+>| | | | output file | |+>| | | | (leave unset | |+>| | | | for no file | |+>| | | | output). | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| parametric | OT_BOOLEAN | GenericType( | Deprecated | CasADi::NLPS |+>| | | ) | option. | olverInterna |+>| | | | Expect F, G, | l |+>| | | | H, J to have | |+>| | | | an | |+>| | | | additional | |+>| | | | input | |+>| | | | argument | |+>| | | | appended at | |+>| | | | the end, | |+>| | | | denoting | |+>| | | | fixed | |+>| | | | parameters. | |+>+--------------+--------------+--------------+--------------+--------------++>| pardiso_iter | OT_INTEGER | 5000 | Maximum Size | CasADi::Ipop |+>| _coarse_size | | | of Coarse | tInternal |+>| | | | Grid Matrix | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| pardiso_iter | OT_REAL | 0.500 | dropping | CasADi::Ipop |+>| _dropping_fa | | | value for | tInternal |+>| ctor | | | incomplete | |+>| | | | factor (see | |+>| | | | IPOPT docume | |+>| | | | ntation) | |+>+--------------+--------------+--------------+--------------+--------------++>| pardiso_iter | OT_REAL | 0.100 | dropping | CasADi::Ipop |+>| _dropping_sc | | | value for | tInternal |+>| hur | | | sparsify | |+>| | | | schur | |+>| | | | complement | |+>| | | | factor (see | |+>| | | | IPOPT docume | |+>| | | | ntation) | |+>+--------------+--------------+--------------+--------------+--------------++>| pardiso_iter | OT_REAL | 5000000 | (see IPOPT d | CasADi::Ipop |+>| _inverse_nor | | | ocumentation | tInternal |+>| m_factor | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| pardiso_iter | OT_INTEGER | 10 | Maximum Size | CasADi::Ipop |+>| _max_levels | | | of Grid | tInternal |+>| | | | Levels (see | |+>| | | | IPOPT docume | |+>| | | | ntation) | |+>+--------------+--------------+--------------+--------------+--------------++>| pardiso_iter | OT_INTEGER | 10000000 | max fill for | CasADi::Ipop |+>| _max_row_fil | | | each row | tInternal |+>| l | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| pardiso_iter | OT_REAL | 0.000 | Relative | CasADi::Ipop |+>| _relative_to | | | Residual | tInternal |+>| l | | | Convergence | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| pardiso_iter | OT_STRING | no | Switch on | CasADi::Ipop |+>| ative | | | iterative | tInternal |+>| | | | solver in | |+>| | | | Pardiso | |+>| | | | library (see | |+>| | | | IPOPT docume | |+>| | | | ntation) | |+>+--------------+--------------+--------------+--------------+--------------++>| pardiso_matc | OT_STRING | complete+2x2 | Matching | CasADi::Ipop |+>| hing_strateg | | | strategy to | tInternal |+>| y | | | be used by | |+>| | | | Pardiso (see | |+>| | | | IPOPT docume | |+>| | | | ntation) | |+>+--------------+--------------+--------------+--------------+--------------++>| pardiso_max_ | OT_INTEGER | 4 | Maximal | CasADi::Ipop |+>| droptol_corr | | | number of | tInternal |+>| ections | | | decreases of | |+>| | | | drop | |+>| | | | tolerance | |+>| | | | during one | |+>| | | | solve. (see | |+>| | | | IPOPT docume | |+>| | | | ntation) | |+>+--------------+--------------+--------------+--------------+--------------++>| pardiso_max_ | OT_INTEGER | 500 | Maximum | CasADi::Ipop |+>| iter | | | number of | tInternal |+>| | | | Krylov- | |+>| | | | Subspace | |+>| | | | Iteration | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| pardiso_msgl | OT_INTEGER | 0 | Pardiso | CasADi::Ipop |+>| vl | | | message | tInternal |+>| | | | level (see | |+>| | | | IPOPT docume | |+>| | | | ntation) | |+>+--------------+--------------+--------------+--------------+--------------++>| pardiso_out_ | OT_INTEGER | 0 | Enables out- | CasADi::Ipop |+>| of_core_powe | | | of-core | tInternal |+>| r | | | variant of | |+>| | | | Pardiso (see | |+>| | | | IPOPT docume | |+>| | | | ntation) | |+>+--------------+--------------+--------------+--------------+--------------++>| pardiso_redo | OT_STRING | no | Toggle for | CasADi::Ipop |+>| _symbolic_fa | | | handling | tInternal |+>| ct_only_if_i | | | case when | |+>| nertia_wrong | | | elements | |+>| | | | were | |+>| | | | perturbed by | |+>| | | | Pardiso. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| pardiso_repe | OT_STRING | no | Interpretati | CasADi::Ipop |+>| ated_perturb | | | on of | tInternal |+>| ation_means_ | | | perturbed | |+>| singular | | | elements. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| pardiso_skip | OT_STRING | no | Always | CasADi::Ipop |+>| _inertia_che | | | pretend | tInternal |+>| ck | | | inertia is | |+>| | | | correct. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| pass_nonline | OT_BOOLEAN | False | n/a | CasADi::Ipop |+>| ar_variables | | | | tInternal |+>+--------------+--------------+--------------+--------------+--------------++>| pen_des_fact | OT_REAL | 0.200 | a parameter | CasADi::Ipop |+>| | | | used in | tInternal |+>| | | | penalty | |+>| | | | parameter | |+>| | | | computation | |+>| | | | (for Chen- | |+>| | | | Goldfarb | |+>| | | | line | |+>| | | | search). | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| pen_init_fac | OT_REAL | 50 | a parameter | CasADi::Ipop |+>| | | | used to | tInternal |+>| | | | choose | |+>| | | | initial | |+>| | | | penalty para | |+>| | | | meterswhen | |+>| | | | the | |+>| | | | regularized | |+>| | | | Newton | |+>| | | | method is | |+>| | | | used. (see | |+>| | | | IPOPT docume | |+>| | | | ntation) | |+>+--------------+--------------+--------------+--------------+--------------++>| pen_theta_ma | OT_REAL | 10000 | Determines | CasADi::Ipop |+>| x_fact | | | upper bound | tInternal |+>| | | | for | |+>| | | | constraint | |+>| | | | violation in | |+>| | | | the filter. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| penalty_init | OT_REAL | 100000 | Maximal | CasADi::Ipop |+>| _max | | | value for | tInternal |+>| | | | the intial | |+>| | | | penalty | |+>| | | | parameter | |+>| | | | (for Chen- | |+>| | | | Goldfarb | |+>| | | | line | |+>| | | | search). | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| penalty_init | OT_REAL | 1 | Minimal | CasADi::Ipop |+>| _min | | | value for | tInternal |+>| | | | the intial | |+>| | | | penalty | |+>| | | | parameter | |+>| | | | for line | |+>| | | | search(for | |+>| | | | Chen- | |+>| | | | Goldfarb | |+>| | | | line | |+>| | | | search). | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| penalty_max | OT_REAL | 1.000e+30 | Maximal | CasADi::Ipop |+>| | | | value for | tInternal |+>| | | | the penalty | |+>| | | | parameter | |+>| | | | (for Chen- | |+>| | | | Goldfarb | |+>| | | | line | |+>| | | | search). | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| penalty_upda | OT_REAL | 10 | LIFENG | CasADi::Ipop |+>| te_compl_tol | | | WRITES THIS. | tInternal |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| penalty_upda | OT_REAL | 0.000 | Threshold | CasADi::Ipop |+>| te_infeasibi | | | for infeasib | tInternal |+>| lity_tol | | | ility in | |+>| | | | penalty | |+>| | | | parameter | |+>| | | | update test. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| perturb_alwa | OT_STRING | no | Active | CasADi::Ipop |+>| ys_cd | | | permanent | tInternal |+>| | | | perturbation | |+>| | | | of | |+>| | | | constraint l | |+>| | | | inearization | |+>| | | | . (see IPOPT | |+>| | | | documentatio | |+>| | | | n) | |+>+--------------+--------------+--------------+--------------+--------------++>| perturb_dec_ | OT_REAL | 0.333 | Decrease | CasADi::Ipop |+>| fact | | | factor for | tInternal |+>| | | | x-s perturba | |+>| | | | tion. (see | |+>| | | | IPOPT docume | |+>| | | | ntation) | |+>+--------------+--------------+--------------+--------------+--------------++>| perturb_inc_ | OT_REAL | 8 | Increase | CasADi::Ipop |+>| fact | | | factor for | tInternal |+>| | | | x-s perturba | |+>| | | | tion. (see | |+>| | | | IPOPT docume | |+>| | | | ntation) | |+>+--------------+--------------+--------------+--------------+--------------++>| perturb_inc_ | OT_REAL | 100 | Increase | CasADi::Ipop |+>| fact_first | | | factor for | tInternal |+>| | | | x-s | |+>| | | | perturbation | |+>| | | | for very | |+>| | | | first pertur | |+>| | | | bation. (see | |+>| | | | IPOPT docume | |+>| | | | ntation) | |+>+--------------+--------------+--------------+--------------+--------------++>| piecewisepen | OT_REAL | 0.000 | LIFENG | CasADi::Ipop |+>| alty_gamma_i | | | WRITES THIS. | tInternal |+>| nfeasi | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| piecewisepen | OT_REAL | 0.000 | LIFENG | CasADi::Ipop |+>| alty_gamma_o | | | WRITES THIS. | tInternal |+>| bj | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| point_pertur | OT_REAL | 10 | Maximal | CasADi::Ipop |+>| bation_radiu | | | perturbation | tInternal |+>| s | | | of an | |+>| | | | evaluation | |+>| | | | point. (see | |+>| | | | IPOPT docume | |+>| | | | ntation) | |+>+--------------+--------------+--------------+--------------+--------------++>| print_info_s | OT_STRING | no | Enables | CasADi::Ipop |+>| tring | | | printing of | tInternal |+>| | | | additional | |+>| | | | info string | |+>| | | | at end of | |+>| | | | iteration | |+>| | | | output. (see | |+>| | | | IPOPT docume | |+>| | | | ntation) | |+>+--------------+--------------+--------------+--------------+--------------++>| print_level | OT_INTEGER | 5 | Output | CasADi::Ipop |+>| | | | verbosity | tInternal |+>| | | | level. (see | |+>| | | | IPOPT docume | |+>| | | | ntation) | |+>+--------------+--------------+--------------+--------------+--------------++>| print_option | OT_STRING | no | Switch to | CasADi::Ipop |+>| s_documentat | | | print all | tInternal |+>| ion | | | algorithmic | |+>| | | | options. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| print_option | OT_STRING | no | Undocumented | CasADi::Ipop |+>| s_latex_mode | | | (see IPOPT d | tInternal |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| print_time | OT_BOOLEAN | True | print | CasADi::Ipop |+>| | | | information | tInternal |+>| | | | about | |+>| | | | execution | |+>| | | | time | |+>+--------------+--------------+--------------+--------------+--------------++>| print_timing | OT_STRING | no | Switch to | CasADi::Ipop |+>| _statistics | | | print timing | tInternal |+>| | | | statistics. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| print_user_o | OT_STRING | no | Print all | CasADi::Ipop |+>| ptions | | | options set | tInternal |+>| | | | by the user. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| quality_func | OT_STRING | none | The | CasADi::Ipop |+>| tion_balanci | | | balancing | tInternal |+>| ng_term | | | term | |+>| | | | included in | |+>| | | | the quality | |+>| | | | function for | |+>| | | | centrality. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| quality_func | OT_STRING | none | The penalty | CasADi::Ipop |+>| tion_central | | | term for | tInternal |+>| ity | | | centrality | |+>| | | | that is | |+>| | | | included in | |+>| | | | quality | |+>| | | | function. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| quality_func | OT_INTEGER | 8 | Maximum | CasADi::Ipop |+>| tion_max_sec | | | number of | tInternal |+>| tion_steps | | | search steps | |+>| | | | during | |+>| | | | direct | |+>| | | | search | |+>| | | | procedure | |+>| | | | determining | |+>| | | | the optimal | |+>| | | | centering | |+>| | | | parameter. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| quality_func | OT_STRING | 2-norm- | Norm used | CasADi::Ipop |+>| tion_norm_ty | | squared | for | tInternal |+>| pe | | | components | |+>| | | | of the | |+>| | | | quality | |+>| | | | function. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| quality_func | OT_REAL | 0 | Tolerance | CasADi::Ipop |+>| tion_section | | | for the | tInternal |+>| _qf_tol | | | golden | |+>| | | | section | |+>| | | | search | |+>| | | | procedure | |+>| | | | determining | |+>| | | | the optimal | |+>| | | | centering | |+>| | | | parameter | |+>| | | | (in the | |+>| | | | function | |+>| | | | value | |+>| | | | space). (see | |+>| | | | IPOPT docume | |+>| | | | ntation) | |+>+--------------+--------------+--------------+--------------+--------------++>| quality_func | OT_REAL | 0.010 | Tolerance | CasADi::Ipop |+>| tion_section | | | for the | tInternal |+>| _sigma_tol | | | section | |+>| | | | search | |+>| | | | procedure | |+>| | | | determining | |+>| | | | the optimal | |+>| | | | centering | |+>| | | | parameter | |+>| | | | (in sigma | |+>| | | | space). (see | |+>| | | | IPOPT docume | |+>| | | | ntation) | |+>+--------------+--------------+--------------+--------------+--------------++>| recalc_y | OT_STRING | no | Tells the | CasADi::Ipop |+>| | | | algorithm to | tInternal |+>| | | | recalculate | |+>| | | | the equality | |+>| | | | and | |+>| | | | inequality | |+>| | | | multipliers | |+>| | | | as least | |+>| | | | square | |+>| | | | estimates. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| recalc_y_fea | OT_REAL | 0.000 | Feasibility | CasADi::Ipop |+>| s_tol | | | threshold | tInternal |+>| | | | for recomput | |+>| | | | ation of | |+>| | | | multipliers. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| regularity_c | OT_BOOLEAN | true | Throw | CasADi::FXIn |+>| heck | | | exceptions | ternal |+>| | | | when NaN or | |+>| | | | Inf appears | |+>| | | | during | |+>| | | | evaluation | |+>+--------------+--------------+--------------+--------------+--------------++>| replace_boun | OT_STRING | no | Indicates if | CasADi::Ipop |+>| ds | | | all variable | tInternal |+>| | | | bounds | |+>| | | | should be | |+>| | | | replaced by | |+>| | | | inequality | |+>| | | | constraints | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| required_inf | OT_REAL | 0.900 | Required | CasADi::Ipop |+>| easibility_r | | | reduction of | tInternal |+>| eduction | | | infeasibilit | |+>| | | | y before | |+>| | | | leaving | |+>| | | | restoration | |+>| | | | phase. (see | |+>| | | | IPOPT docume | |+>| | | | ntation) | |+>+--------------+--------------+--------------+--------------+--------------++>| residual_imp | OT_REAL | 1.000 | Minimal | CasADi::Ipop |+>| rovement_fac | | | required | tInternal |+>| tor | | | reduction of | |+>| | | | residual | |+>| | | | test ratio | |+>| | | | in iterative | |+>| | | | refinement. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| residual_rat | OT_REAL | 0.000 | Iterative | CasADi::Ipop |+>| io_max | | | refinement | tInternal |+>| | | | tolerance | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| residual_rat | OT_REAL | 0.000 | Threshold | CasADi::Ipop |+>| io_singular | | | for | tInternal |+>| | | | declaring | |+>| | | | linear | |+>| | | | system | |+>| | | | singular | |+>| | | | after failed | |+>| | | | iterative | |+>| | | | refinement. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| resto_failur | OT_REAL | 0 | Threshold | CasADi::Ipop |+>| e_feasibilit | | | for primal i | tInternal |+>| y_threshold | | | nfeasibility | |+>| | | | to declare | |+>| | | | failure of | |+>| | | | restoration | |+>| | | | phase. (see | |+>| | | | IPOPT docume | |+>| | | | ntation) | |+>+--------------+--------------+--------------+--------------+--------------++>| resto_penalt | OT_REAL | 1000 | Penalty | CasADi::Ipop |+>| y_parameter | | | parameter in | tInternal |+>| | | | the | |+>| | | | restoration | |+>| | | | phase | |+>| | | | objective | |+>| | | | function. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| resto_proxim | OT_REAL | 1 | Weighting | CasADi::Ipop |+>| ity_weight | | | factor for | tInternal |+>| | | | the | |+>| | | | proximity | |+>| | | | term in | |+>| | | | restoration | |+>| | | | phase | |+>| | | | objective. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| rho | OT_REAL | 0.100 | Value in | CasADi::Ipop |+>| | | | penalty | tInternal |+>| | | | parameter | |+>| | | | update | |+>| | | | formula. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| s_max | OT_REAL | 100 | Scaling | CasADi::Ipop |+>| | | | threshold | tInternal |+>| | | | for the NLP | |+>| | | | error. (see | |+>| | | | IPOPT docume | |+>| | | | ntation) | |+>+--------------+--------------+--------------+--------------+--------------++>| s_phi | OT_REAL | 2.300 | Exponent for | CasADi::Ipop |+>| | | | linear | tInternal |+>| | | | barrier | |+>| | | | function | |+>| | | | model in the | |+>| | | | switching | |+>| | | | rule. (see | |+>| | | | IPOPT docume | |+>| | | | ntation) | |+>+--------------+--------------+--------------+--------------+--------------++>| s_theta | OT_REAL | 1.100 | Exponent for | CasADi::Ipop |+>| | | | current | tInternal |+>| | | | constraint | |+>| | | | violation in | |+>| | | | the | |+>| | | | switching | |+>| | | | rule. (see | |+>| | | | IPOPT docume | |+>| | | | ntation) | |+>+--------------+--------------+--------------+--------------+--------------++>| sb | OT_STRING | no | (see IPOPT d | CasADi::Ipop |+>| | | | ocumentation | tInternal |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| sigma_max | OT_REAL | 100 | Maximum | CasADi::Ipop |+>| | | | value of the | tInternal |+>| | | | centering | |+>| | | | parameter. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| sigma_min | OT_REAL | 0.000 | Minimum | CasADi::Ipop |+>| | | | value of the | tInternal |+>| | | | centering | |+>| | | | parameter. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| skip_corr_if | OT_STRING | yes | Skip the | CasADi::Ipop |+>| _neg_curv | | | corrector | tInternal |+>| | | | step in | |+>| | | | negative | |+>| | | | curvature | |+>| | | | iteration (u | |+>| | | | nsupported!) | |+>| | | | . (see IPOPT | |+>| | | | documentatio | |+>| | | | n) | |+>+--------------+--------------+--------------+--------------+--------------++>| skip_corr_in | OT_STRING | yes | Skip the | CasADi::Ipop |+>| _monotone_mo | | | corrector | tInternal |+>| de | | | step during | |+>| | | | monotone | |+>| | | | barrier | |+>| | | | parameter | |+>| | | | mode (unsupp | |+>| | | | orted!). | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| skip_finaliz | OT_STRING | no | Indicates if | CasADi::Ipop |+>| e_solution_c | | | call to NLP: | tInternal |+>| all | | | :FinalizeSol | |+>| | | | ution after | |+>| | | | optimization | |+>| | | | should be | |+>| | | | suppressed | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| slack_bound_ | OT_REAL | 0.010 | Desired | CasADi::Ipop |+>| frac | | | minimum | tInternal |+>| | | | relative | |+>| | | | distance | |+>| | | | from the | |+>| | | | initial | |+>| | | | slack to | |+>| | | | bound. (see | |+>| | | | IPOPT docume | |+>| | | | ntation) | |+>+--------------+--------------+--------------+--------------+--------------++>| slack_bound_ | OT_REAL | 0.010 | Desired | CasADi::Ipop |+>| push | | | minimum | tInternal |+>| | | | absolute | |+>| | | | distance | |+>| | | | from the | |+>| | | | initial | |+>| | | | slack to | |+>| | | | bound. (see | |+>| | | | IPOPT docume | |+>| | | | ntation) | |+>+--------------+--------------+--------------+--------------+--------------++>| slack_move | OT_REAL | 0.000 | Correction | CasADi::Ipop |+>| | | | size for | tInternal |+>| | | | very small | |+>| | | | slacks. (see | |+>| | | | IPOPT docume | |+>| | | | ntation) | |+>+--------------+--------------+--------------+--------------+--------------++>| soft_resto_p | OT_REAL | 1.000 | Required | CasADi::Ipop |+>| derror_reduc | | | reduction in | tInternal |+>| tion_factor | | | primal-dual | |+>| | | | error in the | |+>| | | | soft | |+>| | | | restoration | |+>| | | | phase. (see | |+>| | | | IPOPT docume | |+>| | | | ntation) | |+>+--------------+--------------+--------------+--------------+--------------++>| sparse | OT_BOOLEAN | true | function is | CasADi::FXIn |+>| | | | sparse | ternal |+>+--------------+--------------+--------------+--------------+--------------++>| sparsity_gen | OT_SPARSITYG | GenericType( | Function | CasADi::FXIn |+>| erator | ENERATOR | ) | that | ternal |+>| | | | provides | |+>| | | | sparsity for | |+>| | | | a given | |+>| | | | input output | |+>| | | | block, | |+>| | | | overrides | |+>| | | | internal | |+>| | | | routines. | |+>| | | | Check docume | |+>| | | | ntation of S | |+>| | | | parsityGener | |+>| | | | ator . | |+>+--------------+--------------+--------------+--------------+--------------++>| start_with_r | OT_STRING | no | Tells | CasADi::Ipop |+>| esto | | | algorithm to | tInternal |+>| | | | switch to | |+>| | | | restoration | |+>| | | | phase in | |+>| | | | first | |+>| | | | iteration. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| store_jacobi | OT_BOOLEAN | false | keep | CasADi::FXIn |+>| ans | | | references | ternal |+>| | | | to generated | |+>| | | | Jacobians in | |+>| | | | order to | |+>| | | | avoid | |+>| | | | generating | |+>| | | | identical | |+>| | | | Jacobians | |+>| | | | multiple | |+>| | | | times | |+>+--------------+--------------+--------------+--------------+--------------++>| suppress_all | OT_STRING | no | Undocumented | CasADi::Ipop |+>| _output | | | (see IPOPT d | tInternal |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| tau_min | OT_REAL | 0.990 | Lower bound | CasADi::Ipop |+>| | | | on fraction- | tInternal |+>| | | | to-the- | |+>| | | | boundary | |+>| | | | parameter | |+>| | | | tau. (see | |+>| | | | IPOPT docume | |+>| | | | ntation) | |+>+--------------+--------------+--------------+--------------+--------------++>| theta_max_fa | OT_REAL | 10000 | Determines | CasADi::Ipop |+>| ct | | | upper bound | tInternal |+>| | | | for | |+>| | | | constraint | |+>| | | | violation in | |+>| | | | the filter. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| theta_min | OT_REAL | 0.000 | LIFENG | CasADi::Ipop |+>| | | | WRITES THIS. | tInternal |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| theta_min_fa | OT_REAL | 0.000 | Determines | CasADi::Ipop |+>| ct | | | constraint | tInternal |+>| | | | violation | |+>| | | | threshold in | |+>| | | | the | |+>| | | | switching | |+>| | | | rule. (see | |+>| | | | IPOPT docume | |+>| | | | ntation) | |+>+--------------+--------------+--------------+--------------+--------------++>| tiny_step_to | OT_REAL | 0.000 | Tolerance | CasADi::Ipop |+>| l | | | for | tInternal |+>| | | | detecting | |+>| | | | numerically | |+>| | | | insignifican | |+>| | | | t steps. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| tiny_step_y_ | OT_REAL | 0.010 | Tolerance | CasADi::Ipop |+>| tol | | | for quitting | tInternal |+>| | | | because of | |+>| | | | numerically | |+>| | | | insignifican | |+>| | | | t steps. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| tol | OT_REAL | 0.000 | Desired | CasADi::Ipop |+>| | | | convergence | tInternal |+>| | | | tolerance | |+>| | | | (relative). | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| user_data | OT_VOIDPTR | GenericType( | A user- | CasADi::FXIn |+>| | | ) | defined | ternal |+>| | | | field that | |+>| | | | can be used | |+>| | | | to identify | |+>| | | | the function | |+>| | | | or pass | |+>| | | | additional | |+>| | | | information | |+>+--------------+--------------+--------------+--------------+--------------++>| var_integer_ | OT_DICTIONAR | None | Integer | CasADi::Ipop |+>| md | Y | | metadata (a | tInternal |+>| | | | dictionary | |+>| | | | with lists | |+>| | | | of integers) | |+>| | | | about | |+>| | | | variables to | |+>| | | | be passed to | |+>| | | | IPOPT | |+>+--------------+--------------+--------------+--------------+--------------++>| var_numeric_ | OT_DICTIONAR | None | Numeric | CasADi::Ipop |+>| md | Y | | metadata (a | tInternal |+>| | | | dictionary | |+>| | | | with lists | |+>| | | | of reals) | |+>| | | | about | |+>| | | | variables to | |+>| | | | be passed to | |+>| | | | IPOPT | |+>+--------------+--------------+--------------+--------------+--------------++>| var_string_m | OT_DICTIONAR | None | String | CasADi::Ipop |+>| d | Y | | metadata (a | tInternal |+>| | | | dictionary | |+>| | | | with lists | |+>| | | | of strings) | |+>| | | | about | |+>| | | | variables to | |+>| | | | be passed to | |+>| | | | IPOPT | |+>+--------------+--------------+--------------+--------------+--------------++>| vartheta | OT_REAL | 0.500 | a parameter | CasADi::Ipop |+>| | | | used to | tInternal |+>| | | | check if the | |+>| | | | fast | |+>| | | | direction | |+>| | | | can be used | |+>| | | | asthe line | |+>| | | | search | |+>| | | | direction | |+>| | | | (for Chen- | |+>| | | | Goldfarb | |+>| | | | line | |+>| | | | search). | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| verbose | OT_BOOLEAN | false | verbose | CasADi::FXIn |+>| | | | evaluation | ternal |+>| | | | for | |+>| | | | debugging | |+>+--------------+--------------+--------------+--------------+--------------++>| warm_start_b | OT_REAL | 0.001 | same as | CasADi::Ipop |+>| ound_frac | | | bound_frac | tInternal |+>| | | | for the | |+>| | | | regular | |+>| | | | initializer. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| warm_start_b | OT_REAL | 0.001 | same as | CasADi::Ipop |+>| ound_push | | | bound_push | tInternal |+>| | | | for the | |+>| | | | regular | |+>| | | | initializer. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| warm_start_e | OT_STRING | no | Tells | CasADi::Ipop |+>| ntire_iterat | | | algorithm | tInternal |+>| e | | | whether to | |+>| | | | use the GetW | |+>| | | | armStartIter | |+>| | | | ate method | |+>| | | | in the NLP. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| warm_start_i | OT_STRING | no | Warm-start | CasADi::Ipop |+>| nit_point | | | for initial | tInternal |+>| | | | point (see | |+>| | | | IPOPT docume | |+>| | | | ntation) | |+>+--------------+--------------+--------------+--------------+--------------++>| warm_start_m | OT_REAL | 0.001 | same as mult | CasADi::Ipop |+>| ult_bound_pu | | | _bound_push | tInternal |+>| sh | | | for the | |+>| | | | regular | |+>| | | | initializer. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| warm_start_m | OT_REAL | 1000000 | Maximum | CasADi::Ipop |+>| ult_init_max | | | initial | tInternal |+>| | | | value for | |+>| | | | the equality | |+>| | | | multipliers. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| warm_start_s | OT_STRING | no | Indicates | CasADi::Ipop |+>| ame_structur | | | whether a | tInternal |+>| e | | | problem with | |+>| | | | a structure | |+>| | | | identical to | |+>| | | | the previous | |+>| | | | one is to be | |+>| | | | solved. (see | |+>| | | | IPOPT docume | |+>| | | | ntation) | |+>+--------------+--------------+--------------+--------------+--------------++>| warm_start_s | OT_REAL | 0.001 | same as slac | CasADi::Ipop |+>| lack_bound_f | | | k_bound_frac | tInternal |+>| rac | | | for the | |+>| | | | regular | |+>| | | | initializer. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| warm_start_s | OT_REAL | 0.001 | same as slac | CasADi::Ipop |+>| lack_bound_p | | | k_bound_push | tInternal |+>| ush | | | for the | |+>| | | | regular | |+>| | | | initializer. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| warm_start_t | OT_REAL | 0 | Unsupported! | CasADi::Ipop |+>| arget_mu | | | (see IPOPT d | tInternal |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| warn_initial | OT_BOOLEAN | false | Warn if the | CasADi::NLPS |+>| _bounds | | | initial | olverInterna |+>| | | | guess does | l |+>| | | | not satisfy | |+>| | | | LBX and UBX | |+>+--------------+--------------+--------------+--------------+--------------++>| watchdog_sho | OT_INTEGER | 10 | Number of | CasADi::Ipop |+>| rtened_iter_ | | | shortened | tInternal |+>| trigger | | | iterations | |+>| | | | that trigger | |+>| | | | the | |+>| | | | watchdog. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| watchdog_tri | OT_INTEGER | 3 | Maximum | CasADi::Ipop |+>| al_iter_max | | | number of | tInternal |+>| | | | watchdog | |+>| | | | iterations. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| wsmp_inexact | OT_REAL | 0 | Drop | CasADi::Ipop |+>| _droptol | | | tolerance | tInternal |+>| | | | for inexact | |+>| | | | factorizatio | |+>| | | | n preconditi | |+>| | | | oner in | |+>| | | | WISMP. (see | |+>| | | | IPOPT docume | |+>| | | | ntation) | |+>+--------------+--------------+--------------+--------------+--------------++>| wsmp_inexact | OT_REAL | 0 | Fill-in | CasADi::Ipop |+>| _fillin_limi | | | limit for | tInternal |+>| t | | | inexact fact | |+>| | | | orization pr | |+>| | | | econditioner | |+>| | | | in WISMP. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| wsmp_iterati | OT_STRING | no | Switches to | CasADi::Ipop |+>| ve | | | iterative | tInternal |+>| | | | solver in | |+>| | | | WSMP. (see | |+>| | | | IPOPT docume | |+>| | | | ntation) | |+>+--------------+--------------+--------------+--------------+--------------++>| wsmp_max_ite | OT_INTEGER | 1000 | Maximal | CasADi::Ipop |+>| r | | | number of | tInternal |+>| | | | iterations | |+>| | | | in iterative | |+>| | | | WISMP (see | |+>| | | | IPOPT docume | |+>| | | | ntation) | |+>+--------------+--------------+--------------+--------------+--------------++>| wsmp_no_pivo | OT_STRING | no | Use the | CasADi::Ipop |+>| ting | | | static | tInternal |+>| | | | pivoting | |+>| | | | option of | |+>| | | | WSMP. (see | |+>| | | | IPOPT docume | |+>| | | | ntation) | |+>+--------------+--------------+--------------+--------------+--------------++>| wsmp_num_thr | OT_INTEGER | 1 | Number of | CasADi::Ipop |+>| eads | | | threads to | tInternal |+>| | | | be used in | |+>| | | | WSMP (see | |+>| | | | IPOPT docume | |+>| | | | ntation) | |+>+--------------+--------------+--------------+--------------+--------------++>| wsmp_orderin | OT_INTEGER | 1 | Determines | CasADi::Ipop |+>| g_option | | | how ordering | tInternal |+>| | | | is done in | |+>| | | | WSMP | |+>| | | | (IPARM(16) | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| wsmp_orderin | OT_INTEGER | 1 | Determines | CasADi::Ipop |+>| g_option2 | | | how ordering | tInternal |+>| | | | is done in | |+>| | | | WSMP | |+>| | | | (IPARM(20) | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| wsmp_pivtol | OT_REAL | 0.000 | Pivot | CasADi::Ipop |+>| | | | tolerance | tInternal |+>| | | | for the | |+>| | | | linear | |+>| | | | solver WSMP. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| wsmp_pivtolm | OT_REAL | 0.100 | Maximum | CasADi::Ipop |+>| ax | | | pivot | tInternal |+>| | | | tolerance | |+>| | | | for the | |+>| | | | linear | |+>| | | | solver WSMP. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| wsmp_scaling | OT_INTEGER | 0 | Determines | CasADi::Ipop |+>| | | | how the | tInternal |+>| | | | matrix is | |+>| | | | scaled by | |+>| | | | WSMP. (see | |+>| | | | IPOPT docume | |+>| | | | ntation) | |+>+--------------+--------------+--------------+--------------+--------------++>| wsmp_singula | OT_REAL | 0.000 | WSMP's | CasADi::Ipop |+>| rity_thresho | | | singularity | tInternal |+>| ld | | | threshold. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| wsmp_skip_in | OT_STRING | no | Always | CasADi::Ipop |+>| ertia_check | | | pretent | tInternal |+>| | | | inertia is | |+>| | | | correct. | |+>| | | | (see IPOPT d | |+>| | | | ocumentation | |+>| | | | ) | |+>+--------------+--------------+--------------+--------------+--------------++>| wsmp_write_m | OT_INTEGER | -1 | Iteration in | CasADi::Ipop |+>| atrix_iterat | | | which the | tInternal |+>| ion | | | matrices are | |+>| | | | written to | |+>| | | | files. (see | |+>| | | | IPOPT docume | |+>| | | | ntation) | |+>+--------------+--------------+--------------+--------------+--------------++>+>>List of available monitors+>+-------------+-----------------------++>| Id | Used in |+>+=============+=======================++>| eval_f | CasADi::IpoptInternal |+>+-------------+-----------------------++>| eval_g | CasADi::IpoptInternal |+>+-------------+-----------------------++>| eval_grad_f | CasADi::IpoptInternal |+>+-------------+-----------------------++>| eval_jac_g | CasADi::IpoptInternal |+>+-------------+-----------------------++>| inputs | CasADi::FXInternal |+>+-------------+-----------------------++>| outputs | CasADi::FXInternal |+>+-------------+-----------------------++>+>>List of available stats+>+--------------------+-----------------------++>| Id | Used in |+>+====================+=======================++>| con_integer_md | CasADi::IpoptInternal |+>+--------------------+-----------------------++>| con_numeric_md | CasADi::IpoptInternal |+>+--------------------+-----------------------++>| con_string_md | CasADi::IpoptInternal |+>+--------------------+-----------------------++>| iter_count | CasADi::IpoptInternal |+>+--------------------+-----------------------++>| iteration | CasADi::IpoptInternal |+>+--------------------+-----------------------++>| return_status | CasADi::IpoptInternal |+>+--------------------+-----------------------++>| t_callback_fun | CasADi::IpoptInternal |+>+--------------------+-----------------------++>| t_callback_prepare | CasADi::IpoptInternal |+>+--------------------+-----------------------++>| t_eval_f | CasADi::IpoptInternal |+>+--------------------+-----------------------++>| t_eval_g | CasADi::IpoptInternal |+>+--------------------+-----------------------++>| t_eval_grad_f | CasADi::IpoptInternal |+>+--------------------+-----------------------++>| t_eval_h | CasADi::IpoptInternal |+>+--------------------+-----------------------++>| t_eval_jac_g | CasADi::IpoptInternal |+>+--------------------+-----------------------++>| t_mainloop | CasADi::IpoptInternal |+>+--------------------+-----------------------++>| var_integer_md | CasADi::IpoptInternal |+>+--------------------+-----------------------++>| var_numeric_md | CasADi::IpoptInternal |+>+--------------------+-----------------------++>| var_string_md | CasADi::IpoptInternal |+>+--------------------+-----------------------++>+>Diagrams+>+>C++ includes: ipopt_solver.hpp +-}+newtype IpoptSolver = IpoptSolver (ForeignPtr IpoptSolver')+-- typeclass decl+class IpoptSolverClass a where+ castIpoptSolver :: a -> IpoptSolver+instance IpoptSolverClass IpoptSolver where+ castIpoptSolver = id++-- baseclass instances+instance SharedObjectClass IpoptSolver where+ castSharedObject (IpoptSolver x) = SharedObject (castForeignPtr x)++instance PrintableObjectClass IpoptSolver where+ castPrintableObject (IpoptSolver x) = PrintableObject (castForeignPtr x)++instance IOInterfaceFXClass IpoptSolver where+ castIOInterfaceFX (IpoptSolver x) = IOInterfaceFX (castForeignPtr x)++instance OptionsFunctionalityClass IpoptSolver where+ castOptionsFunctionality (IpoptSolver x) = OptionsFunctionality (castForeignPtr x)++instance FXClass IpoptSolver where+ castFX (IpoptSolver x) = FX (castForeignPtr x)+++-- helper instances+instance Marshal IpoptSolver (Ptr IpoptSolver') where+ withMarshal (IpoptSolver x) f = withForeignPtr x f+instance ForeignPtrWrapper IpoptSolver IpoptSolver' where+ unwrapForeignPtr (IpoptSolver x) = x+instance WrapReturn (ForeignPtr IpoptSolver') IpoptSolver where+ wrapReturn = return . IpoptSolver+++-- raw decl+data SXMatrix'+-- data decl+{-|+>General sparse matrix class General sparse matrix class that is designed+>with the idea that "everything is a matrix", that is, also scalars and+>vectors. This philosophy makes it easy to use and to interface in+>particularily with Python and Matlab/Octave. .+>+>The syntax tries to stay as close as possible to the ublas syntax when it+>comes to vector/matrix operations.+>+>Index starts with 0. Index flatten happens as follows: (i,j) -> k =+>j+i*size2() Vectors are considered to be column vectors.+>+>The storage format is a (modified) compressed row storage (CRS) format. This+>way, a vector element can always be accessed in constant time.+>+>Matrix<T> is polymorphic with a std::vector<T> that contain all non-+>identical-zero elements. The sparsity can be accessed with CRSSparsity&+>sparsity()+>+>Joel Andersson+>+>C++ includes: matrix.hpp +-}+newtype SXMatrix = SXMatrix (ForeignPtr SXMatrix')+-- typeclass decl+class SXMatrixClass a where+ castSXMatrix :: a -> SXMatrix+instance SXMatrixClass SXMatrix where+ castSXMatrix = id++-- baseclass instances+instance PrintableObjectClass SXMatrix where+ castPrintableObject (SXMatrix x) = PrintableObject (castForeignPtr x)+++-- helper instances+instance Marshal SXMatrix (Ptr SXMatrix') where+ withMarshal (SXMatrix x) f = withForeignPtr x f+instance ForeignPtrWrapper SXMatrix SXMatrix' where+ unwrapForeignPtr (SXMatrix x) = x+instance WrapReturn (ForeignPtr SXMatrix') SXMatrix where+ wrapReturn = return . SXMatrix+++-- raw decl+data IOScheme'+-- data decl+{-|+>Class with mapping between names and indices.+>+>Joris Gillis+>+>C++ includes: io_scheme.hpp +-}+newtype IOScheme = IOScheme (ForeignPtr IOScheme')+-- typeclass decl+class IOSchemeClass a where+ castIOScheme :: a -> IOScheme+instance IOSchemeClass IOScheme where+ castIOScheme = id++-- baseclass instances+instance SharedObjectClass IOScheme where+ castSharedObject (IOScheme x) = SharedObject (castForeignPtr x)++instance PrintableObjectClass IOScheme where+ castPrintableObject (IOScheme x) = PrintableObject (castForeignPtr x)+++-- helper instances+instance Marshal IOScheme (Ptr IOScheme') where+ withMarshal (IOScheme x) f = withForeignPtr x f+instance ForeignPtrWrapper IOScheme IOScheme' where+ unwrapForeignPtr (IOScheme x) = x+instance WrapReturn (ForeignPtr IOScheme') IOScheme where+ wrapReturn = return . IOScheme+++-- raw decl+data DMatrix'+-- data decl+{-|+>General sparse matrix class General sparse matrix class that is designed+>with the idea that "everything is a matrix", that is, also scalars and+>vectors. This philosophy makes it easy to use and to interface in+>particularily with Python and Matlab/Octave. .+>+>The syntax tries to stay as close as possible to the ublas syntax when it+>comes to vector/matrix operations.+>+>Index starts with 0. Index flatten happens as follows: (i,j) -> k =+>j+i*size2() Vectors are considered to be column vectors.+>+>The storage format is a (modified) compressed row storage (CRS) format. This+>way, a vector element can always be accessed in constant time.+>+>Matrix<T> is polymorphic with a std::vector<T> that contain all non-+>identical-zero elements. The sparsity can be accessed with CRSSparsity&+>sparsity()+>+>Joel Andersson+>+>C++ includes: matrix.hpp +-}+newtype DMatrix = DMatrix (ForeignPtr DMatrix')+-- typeclass decl+class DMatrixClass a where+ castDMatrix :: a -> DMatrix+instance DMatrixClass DMatrix where+ castDMatrix = id++-- baseclass instances+instance PrintableObjectClass DMatrix where+ castPrintableObject (DMatrix x) = PrintableObject (castForeignPtr x)+++-- helper instances+instance Marshal DMatrix (Ptr DMatrix') where+ withMarshal (DMatrix x) f = withForeignPtr x f+instance ForeignPtrWrapper DMatrix DMatrix' where+ unwrapForeignPtr (DMatrix x) = x+instance WrapReturn (ForeignPtr DMatrix') DMatrix where+ wrapReturn = return . DMatrix+++-- raw decl+data MX'+-- data decl+{-|+>MX - Matrix expression The MX class is used to build up trees made up from+>MXNodes. It is a more general graph representation than the scalar+>expression, SX, and much less efficient for small objects. On the other+>hand, the class allows much more general operations than does SX, in+>particular matrix valued operations and calls to arbitrary differentiable+>functions.+>+>The MX class is designed to have identical syntax with the Matrix<> template+>class, and uses Matrix<double> as its internal representation of the values+>at a node. By keeping the syntaxes identical, it is possible to switch from+>one class to the other, as well as inlining MX functions to SX functions.+>+>Note that an operation is always "lazy", making a matrix multiplication+>will create a matrix multiplication node, not perform the actual+>multiplication.+>+>Joel Andersson+>+>C++ includes: mx.hpp +-}+newtype MX = MX (ForeignPtr MX')+-- typeclass decl+class MXClass a where+ castMX :: a -> MX+instance MXClass MX where+ castMX = id++-- baseclass instances+instance SharedObjectClass MX where+ castSharedObject (MX x) = SharedObject (castForeignPtr x)++instance PrintableObjectClass MX where+ castPrintableObject (MX x) = PrintableObject (castForeignPtr x)+++-- helper instances+instance Marshal MX (Ptr MX') where+ withMarshal (MX x) f = withForeignPtr x f+instance ForeignPtrWrapper MX MX' where+ unwrapForeignPtr (MX x) = x+instance WrapReturn (ForeignPtr MX') MX where+ wrapReturn = return . MX+++-- raw decl+data CasadiOptions'+-- data decl+{-|+>Collects global CasADi options.+>+>Note to developers: use sparingly. Global options are - in general - a+>rather bad idea+>+>this class must never be instantiated. Access its static members directly+>+>Joris Gillis+>+>C++ includes: casadi_options.hpp +-}+newtype CasadiOptions = CasadiOptions (ForeignPtr CasadiOptions')+-- typeclass decl+class CasadiOptionsClass a where+ castCasadiOptions :: a -> CasadiOptions+instance CasadiOptionsClass CasadiOptions where+ castCasadiOptions = id++-- baseclass instances++-- helper instances+instance Marshal CasadiOptions (Ptr CasadiOptions') where+ withMarshal (CasadiOptions x) f = withForeignPtr x f+instance ForeignPtrWrapper CasadiOptions CasadiOptions' where+ unwrapForeignPtr (CasadiOptions x) = x+instance WrapReturn (ForeignPtr CasadiOptions') CasadiOptions where+ wrapReturn = return . CasadiOptions+++-- raw decl+data Callback'+-- data decl+{-|+>Callback.+>+>In C++, supply a CallbackCPtr function pointer+>+>In python, supply a callable, annotated with pycallback decorator+>+>C++ includes: functor.hpp +-}+newtype Callback = Callback (ForeignPtr Callback')+-- typeclass decl+class CallbackClass a where+ castCallback :: a -> Callback+instance CallbackClass Callback where+ castCallback = id++-- baseclass instances+instance SharedObjectClass Callback where+ castSharedObject (Callback x) = SharedObject (castForeignPtr x)++instance FunctorClass Callback where+ castFunctor (Callback x) = Functor (castForeignPtr x)++instance PrintableObjectClass Callback where+ castPrintableObject (Callback x) = PrintableObject (castForeignPtr x)+++-- helper instances+instance Marshal Callback (Ptr Callback') where+ withMarshal (Callback x) f = withForeignPtr x f+instance ForeignPtrWrapper Callback Callback' where+ unwrapForeignPtr (Callback x) = x+instance WrapReturn (ForeignPtr Callback') Callback where+ wrapReturn = return . Callback+++-- raw decl+data CustomEvaluate'+-- data decl+{-|+>CustomEvaluate.+>+>In C++, supply a CustomEvaluateCPtr function pointer+>+>In python, supply a callable, annotated with pyevaluate decorator+>+>C++ includes: functor.hpp +-}+newtype CustomEvaluate = CustomEvaluate (ForeignPtr CustomEvaluate')+-- typeclass decl+class CustomEvaluateClass a where+ castCustomEvaluate :: a -> CustomEvaluate+instance CustomEvaluateClass CustomEvaluate where+ castCustomEvaluate = id++-- baseclass instances+instance SharedObjectClass CustomEvaluate where+ castSharedObject (CustomEvaluate x) = SharedObject (castForeignPtr x)++instance FunctorClass CustomEvaluate where+ castFunctor (CustomEvaluate x) = Functor (castForeignPtr x)++instance PrintableObjectClass CustomEvaluate where+ castPrintableObject (CustomEvaluate x) = PrintableObject (castForeignPtr x)+++-- helper instances+instance Marshal CustomEvaluate (Ptr CustomEvaluate') where+ withMarshal (CustomEvaluate x) f = withForeignPtr x f+instance ForeignPtrWrapper CustomEvaluate CustomEvaluate' where+ unwrapForeignPtr (CustomEvaluate x) = x+instance WrapReturn (ForeignPtr CustomEvaluate') CustomEvaluate where+ wrapReturn = return . CustomEvaluate+++-- raw decl+data ExternalFunction'+-- data decl+{-|+>Interface for a function that is not implemented by CasADi symbolics.+>+>Joel Andersson+>+>>List of available options+>+--------------+--------------+--------------+--------------+--------------++>| Id | Type | Default | Description | Used in |+>+==============+==============+==============+==============+==============++>| ad_mode | OT_STRING | "automatic" | How to | CasADi::FXIn |+>| | | | calculate | ternal |+>| | | | the | |+>| | | | Jacobians. | |+>| | | | (forward: | |+>| | | | only forward | |+>| | | | mode|reverse | |+>| | | | : only | |+>| | | | adjoint mode | |+>| | | | |automatic: | |+>| | | | a heuristic | |+>| | | | decides | |+>| | | | which is | |+>| | | | more | |+>| | | | appropriate) | |+>+--------------+--------------+--------------+--------------+--------------++>| gather_stats | OT_BOOLEAN | false | Flag to | CasADi::FXIn |+>| | | | indicate | ternal |+>| | | | wether | |+>| | | | statistics | |+>| | | | must be | |+>| | | | gathered | |+>+--------------+--------------+--------------+--------------+--------------++>| inputs_check | OT_BOOLEAN | true | Throw | CasADi::FXIn |+>| | | | exceptions | ternal |+>| | | | when the | |+>| | | | numerical | |+>| | | | values of | |+>| | | | the inputs | |+>| | | | don't make | |+>| | | | sense | |+>+--------------+--------------+--------------+--------------+--------------++>| jacobian_gen | OT_JACOBIANG | GenericType( | Function | CasADi::FXIn |+>| erator | ENERATOR | ) | that returns | ternal |+>| | | | a Jacobian | |+>| | | | function | |+>| | | | given a set | |+>| | | | of desired | |+>| | | | Jacobian | |+>| | | | blocks, | |+>| | | | overrides | |+>| | | | internal | |+>| | | | routines. | |+>| | | | Check docume | |+>| | | | ntation of J | |+>| | | | acobianGener | |+>| | | | ator . | |+>+--------------+--------------+--------------+--------------+--------------++>| max_number_o | OT_INTEGER | optimized_nu | Allow "numbe | CasADi::FXIn |+>| f_adj_dir | | m_dir | r_of_adj_dir | ternal |+>| | | | " to grow | |+>| | | | until it | |+>| | | | reaches this | |+>| | | | number | |+>+--------------+--------------+--------------+--------------+--------------++>| max_number_o | OT_INTEGER | optimized_nu | Allow "numbe | CasADi::FXIn |+>| f_fwd_dir | | m_dir | r_of_fwd_dir | ternal |+>| | | | " to grow | |+>| | | | until it | |+>| | | | reaches this | |+>| | | | number | |+>+--------------+--------------+--------------+--------------+--------------++>| monitor | OT_STRINGVEC | GenericType( | Monitors to | CasADi::FXIn |+>| | TOR | ) | be activated | ternal |+>| | | | (inputs|outp | |+>| | | | uts) | |+>+--------------+--------------+--------------+--------------+--------------++>| name | OT_STRING | "unnamed_sha | name of the | CasADi::Opti |+>| | | red_object" | object | onsFunctiona |+>| | | | | lityNode |+>+--------------+--------------+--------------+--------------+--------------++>| number_of_ad | OT_INTEGER | 1 | number of | CasADi::FXIn |+>| j_dir | | | adjoint | ternal |+>| | | | derivatives | |+>| | | | to be | |+>| | | | calculated s | |+>| | | | imultanously | |+>+--------------+--------------+--------------+--------------+--------------++>| number_of_fw | OT_INTEGER | 1 | number of | CasADi::FXIn |+>| d_dir | | | forward | ternal |+>| | | | derivatives | |+>| | | | to be | |+>| | | | calculated s | |+>| | | | imultanously | |+>+--------------+--------------+--------------+--------------+--------------++>| numeric_hess | OT_BOOLEAN | false | Calculate | CasADi::FXIn |+>| ian | | | Hessians | ternal |+>| | | | numerically | |+>| | | | (using | |+>| | | | directional | |+>| | | | derivatives) | |+>| | | | rather than | |+>| | | | with the | |+>| | | | built-in | |+>| | | | method | |+>+--------------+--------------+--------------+--------------+--------------++>| numeric_jaco | OT_BOOLEAN | false | Calculate | CasADi::FXIn |+>| bian | | | Jacobians | ternal |+>| | | | numerically | |+>| | | | (using | |+>| | | | directional | |+>| | | | derivatives) | |+>| | | | rather than | |+>| | | | with the | |+>| | | | built-in | |+>| | | | method | |+>+--------------+--------------+--------------+--------------+--------------++>| regularity_c | OT_BOOLEAN | true | Throw | CasADi::FXIn |+>| heck | | | exceptions | ternal |+>| | | | when NaN or | |+>| | | | Inf appears | |+>| | | | during | |+>| | | | evaluation | |+>+--------------+--------------+--------------+--------------+--------------++>| sparse | OT_BOOLEAN | true | function is | CasADi::FXIn |+>| | | | sparse | ternal |+>+--------------+--------------+--------------+--------------+--------------++>| sparsity_gen | OT_SPARSITYG | GenericType( | Function | CasADi::FXIn |+>| erator | ENERATOR | ) | that | ternal |+>| | | | provides | |+>| | | | sparsity for | |+>| | | | a given | |+>| | | | input output | |+>| | | | block, | |+>| | | | overrides | |+>| | | | internal | |+>| | | | routines. | |+>| | | | Check docume | |+>| | | | ntation of S | |+>| | | | parsityGener | |+>| | | | ator . | |+>+--------------+--------------+--------------+--------------+--------------++>| store_jacobi | OT_BOOLEAN | false | keep | CasADi::FXIn |+>| ans | | | references | ternal |+>| | | | to generated | |+>| | | | Jacobians in | |+>| | | | order to | |+>| | | | avoid | |+>| | | | generating | |+>| | | | identical | |+>| | | | Jacobians | |+>| | | | multiple | |+>| | | | times | |+>+--------------+--------------+--------------+--------------+--------------++>| user_data | OT_VOIDPTR | GenericType( | A user- | CasADi::FXIn |+>| | | ) | defined | ternal |+>| | | | field that | |+>| | | | can be used | |+>| | | | to identify | |+>| | | | the function | |+>| | | | or pass | |+>| | | | additional | |+>| | | | information | |+>+--------------+--------------+--------------+--------------+--------------++>| verbose | OT_BOOLEAN | false | verbose | CasADi::FXIn |+>| | | | evaluation | ternal |+>| | | | for | |+>| | | | debugging | |+>+--------------+--------------+--------------+--------------+--------------++>+>Diagrams+>+>C++ includes: external_function.hpp +-}+newtype ExternalFunction = ExternalFunction (ForeignPtr ExternalFunction')+-- typeclass decl+class ExternalFunctionClass a where+ castExternalFunction :: a -> ExternalFunction+instance ExternalFunctionClass ExternalFunction where+ castExternalFunction = id++-- baseclass instances+instance SharedObjectClass ExternalFunction where+ castSharedObject (ExternalFunction x) = SharedObject (castForeignPtr x)++instance PrintableObjectClass ExternalFunction where+ castPrintableObject (ExternalFunction x) = PrintableObject (castForeignPtr x)++instance IOInterfaceFXClass ExternalFunction where+ castIOInterfaceFX (ExternalFunction x) = IOInterfaceFX (castForeignPtr x)++instance OptionsFunctionalityClass ExternalFunction where+ castOptionsFunctionality (ExternalFunction x) = OptionsFunctionality (castForeignPtr x)++instance FXClass ExternalFunction where+ castFX (ExternalFunction x) = FX (castForeignPtr x)+++-- helper instances+instance Marshal ExternalFunction (Ptr ExternalFunction') where+ withMarshal (ExternalFunction x) f = withForeignPtr x f+instance ForeignPtrWrapper ExternalFunction ExternalFunction' where+ unwrapForeignPtr (ExternalFunction x) = x+instance WrapReturn (ForeignPtr ExternalFunction') ExternalFunction where+ wrapReturn = return . ExternalFunction+++-- raw decl+data CSparse'+-- data decl+{-|+>LinearSolver with CSparse Interface.+>+>Solves the linear system X*A = B or X*A^T = B for X with A square and non-+>singular+>+>If A is structurally singular, an error will be thrown during init. If A is+>numerically singular, the prepare step will fail.+>+>Note: the transposed form is equivalent to A X^T = B^T which is the same as+>A x = b with x = X^T, b = B^T+>+>CSparse is an CasADi::FX mapping from 2 inputs [ A (matrix),b (vector)] to+>one output [x (vector)].+>+>The usual procedure to use CSparse is: init()+>+>set the first input (A)+>+>prepare()+>+>set the second input (b)+>+>solve()+>+>Repeat steps 4 and 5 to work with other b vectors.+>+>The method evaluate() combines the prepare() and solve() step and is+>therefore more expensive if A is invariant.+>+>>Input scheme: CasADi::LinsolInput (LINSOL_NUM_IN = 4) [linsolIn]+>+-----------+-------+------------------------------------------------++>| Full name | Short | Description |+>+===========+=======+================================================++>| LINSOL_A | A | The square matrix A: sparse, (n x n). . |+>+-----------+-------+------------------------------------------------++>| LINSOL_B | B | The right-hand-side matrix b: dense, (m x n) . |+>+-----------+-------+------------------------------------------------++>+>>Output scheme: CasADi::LinsolOutput (LINSOL_NUM_OUT = 2) [linsolOut]+>+-----------+-------+----------------------------------------------++>| Full name | Short | Description |+>+===========+=======+==============================================++>| LINSOL_X | X | Solution to the linear system of equations . |+>+-----------+-------+----------------------------------------------++>+>>List of available options+>+--------------+--------------+--------------+--------------+--------------++>| Id | Type | Default | Description | Used in |+>+==============+==============+==============+==============+==============++>| ad_mode | OT_STRING | "automatic" | How to | CasADi::FXIn |+>| | | | calculate | ternal |+>| | | | the | |+>| | | | Jacobians. | |+>| | | | (forward: | |+>| | | | only forward | |+>| | | | mode|reverse | |+>| | | | : only | |+>| | | | adjoint mode | |+>| | | | |automatic: | |+>| | | | a heuristic | |+>| | | | decides | |+>| | | | which is | |+>| | | | more | |+>| | | | appropriate) | |+>+--------------+--------------+--------------+--------------+--------------++>| gather_stats | OT_BOOLEAN | false | Flag to | CasADi::FXIn |+>| | | | indicate | ternal |+>| | | | wether | |+>| | | | statistics | |+>| | | | must be | |+>| | | | gathered | |+>+--------------+--------------+--------------+--------------+--------------++>| inputs_check | OT_BOOLEAN | true | Throw | CasADi::FXIn |+>| | | | exceptions | ternal |+>| | | | when the | |+>| | | | numerical | |+>| | | | values of | |+>| | | | the inputs | |+>| | | | don't make | |+>| | | | sense | |+>+--------------+--------------+--------------+--------------+--------------++>| jacobian_gen | OT_JACOBIANG | GenericType( | Function | CasADi::FXIn |+>| erator | ENERATOR | ) | that returns | ternal |+>| | | | a Jacobian | |+>| | | | function | |+>| | | | given a set | |+>| | | | of desired | |+>| | | | Jacobian | |+>| | | | blocks, | |+>| | | | overrides | |+>| | | | internal | |+>| | | | routines. | |+>| | | | Check docume | |+>| | | | ntation of J | |+>| | | | acobianGener | |+>| | | | ator . | |+>+--------------+--------------+--------------+--------------+--------------++>| max_number_o | OT_INTEGER | optimized_nu | Allow "numbe | CasADi::FXIn |+>| f_adj_dir | | m_dir | r_of_adj_dir | ternal |+>| | | | " to grow | |+>| | | | until it | |+>| | | | reaches this | |+>| | | | number | |+>+--------------+--------------+--------------+--------------+--------------++>| max_number_o | OT_INTEGER | optimized_nu | Allow "numbe | CasADi::FXIn |+>| f_fwd_dir | | m_dir | r_of_fwd_dir | ternal |+>| | | | " to grow | |+>| | | | until it | |+>| | | | reaches this | |+>| | | | number | |+>+--------------+--------------+--------------+--------------+--------------++>| monitor | OT_STRINGVEC | GenericType( | Monitors to | CasADi::FXIn |+>| | TOR | ) | be activated | ternal |+>| | | | (inputs|outp | |+>| | | | uts) | |+>+--------------+--------------+--------------+--------------+--------------++>| name | OT_STRING | "unnamed_sha | name of the | CasADi::Opti |+>| | | red_object" | object | onsFunctiona |+>| | | | | lityNode |+>+--------------+--------------+--------------+--------------+--------------++>| number_of_ad | OT_INTEGER | 1 | number of | CasADi::FXIn |+>| j_dir | | | adjoint | ternal |+>| | | | derivatives | |+>| | | | to be | |+>| | | | calculated s | |+>| | | | imultanously | |+>+--------------+--------------+--------------+--------------+--------------++>| number_of_fw | OT_INTEGER | 1 | number of | CasADi::FXIn |+>| d_dir | | | forward | ternal |+>| | | | derivatives | |+>| | | | to be | |+>| | | | calculated s | |+>| | | | imultanously | |+>+--------------+--------------+--------------+--------------+--------------++>| numeric_hess | OT_BOOLEAN | false | Calculate | CasADi::FXIn |+>| ian | | | Hessians | ternal |+>| | | | numerically | |+>| | | | (using | |+>| | | | directional | |+>| | | | derivatives) | |+>| | | | rather than | |+>| | | | with the | |+>| | | | built-in | |+>| | | | method | |+>+--------------+--------------+--------------+--------------+--------------++>| numeric_jaco | OT_BOOLEAN | false | Calculate | CasADi::FXIn |+>| bian | | | Jacobians | ternal |+>| | | | numerically | |+>| | | | (using | |+>| | | | directional | |+>| | | | derivatives) | |+>| | | | rather than | |+>| | | | with the | |+>| | | | built-in | |+>| | | | method | |+>+--------------+--------------+--------------+--------------+--------------++>| regularity_c | OT_BOOLEAN | true | Throw | CasADi::FXIn |+>| heck | | | exceptions | ternal |+>| | | | when NaN or | |+>| | | | Inf appears | |+>| | | | during | |+>| | | | evaluation | |+>+--------------+--------------+--------------+--------------+--------------++>| sparse | OT_BOOLEAN | true | function is | CasADi::FXIn |+>| | | | sparse | ternal |+>+--------------+--------------+--------------+--------------+--------------++>| sparsity_gen | OT_SPARSITYG | GenericType( | Function | CasADi::FXIn |+>| erator | ENERATOR | ) | that | ternal |+>| | | | provides | |+>| | | | sparsity for | |+>| | | | a given | |+>| | | | input output | |+>| | | | block, | |+>| | | | overrides | |+>| | | | internal | |+>| | | | routines. | |+>| | | | Check docume | |+>| | | | ntation of S | |+>| | | | parsityGener | |+>| | | | ator . | |+>+--------------+--------------+--------------+--------------+--------------++>| store_jacobi | OT_BOOLEAN | false | keep | CasADi::FXIn |+>| ans | | | references | ternal |+>| | | | to generated | |+>| | | | Jacobians in | |+>| | | | order to | |+>| | | | avoid | |+>| | | | generating | |+>| | | | identical | |+>| | | | Jacobians | |+>| | | | multiple | |+>| | | | times | |+>+--------------+--------------+--------------+--------------+--------------++>| user_data | OT_VOIDPTR | GenericType( | A user- | CasADi::FXIn |+>| | | ) | defined | ternal |+>| | | | field that | |+>| | | | can be used | |+>| | | | to identify | |+>| | | | the function | |+>| | | | or pass | |+>| | | | additional | |+>| | | | information | |+>+--------------+--------------+--------------+--------------+--------------++>| verbose | OT_BOOLEAN | false | verbose | CasADi::FXIn |+>| | | | evaluation | ternal |+>| | | | for | |+>| | | | debugging | |+>+--------------+--------------+--------------+--------------+--------------++>+>Diagrams+>+>C++ includes: csparse.hpp +-}+newtype CSparse = CSparse (ForeignPtr CSparse')+-- typeclass decl+class CSparseClass a where+ castCSparse :: a -> CSparse+instance CSparseClass CSparse where+ castCSparse = id++-- baseclass instances+instance SharedObjectClass CSparse where+ castSharedObject (CSparse x) = SharedObject (castForeignPtr x)++instance PrintableObjectClass CSparse where+ castPrintableObject (CSparse x) = PrintableObject (castForeignPtr x)++instance IOInterfaceFXClass CSparse where+ castIOInterfaceFX (CSparse x) = IOInterfaceFX (castForeignPtr x)++instance OptionsFunctionalityClass CSparse where+ castOptionsFunctionality (CSparse x) = OptionsFunctionality (castForeignPtr x)++instance FXClass CSparse where+ castFX (CSparse x) = FX (castForeignPtr x)+++-- helper instances+instance Marshal CSparse (Ptr CSparse') where+ withMarshal (CSparse x) f = withForeignPtr x f+instance ForeignPtrWrapper CSparse CSparse' where+ unwrapForeignPtr (CSparse x) = x+instance WrapReturn (ForeignPtr CSparse') CSparse where+ wrapReturn = return . CSparse+++-- raw decl+data SX'+-- data decl+{-|+>The basic scalar symbolic class of CasADi.+>+>Joel Andersson+>+>C++ includes: sx.hpp +-}+newtype SX = SX (ForeignPtr SX')+-- typeclass decl+class SXClass a where+ castSX :: a -> SX+instance SXClass SX where+ castSX = id++-- baseclass instances++-- helper instances+instance Marshal SX (Ptr SX') where+ withMarshal (SX x) f = withForeignPtr x f+instance ForeignPtrWrapper SX SX' where+ unwrapForeignPtr (SX x) = x+instance WrapReturn (ForeignPtr SX') SX where+ wrapReturn = return . SX+++-- raw decl+data CasadiMeta'+-- data decl+{-|+>Collects global CasADi meta information.+>+>Joris Gillis+>+>C++ includes: casadi_meta.hpp +-}+newtype CasadiMeta = CasadiMeta (ForeignPtr CasadiMeta')+-- typeclass decl+class CasadiMetaClass a where+ castCasadiMeta :: a -> CasadiMeta+instance CasadiMetaClass CasadiMeta where+ castCasadiMeta = id++-- baseclass instances++-- helper instances+instance Marshal CasadiMeta (Ptr CasadiMeta') where+ withMarshal (CasadiMeta x) f = withForeignPtr x f+instance ForeignPtrWrapper CasadiMeta CasadiMeta' where+ unwrapForeignPtr (CasadiMeta x) = x+instance WrapReturn (ForeignPtr CasadiMeta') CasadiMeta where+ wrapReturn = return . CasadiMeta+++-- raw decl+data Functor'+-- data decl+{-|+>Internal class for Functor.+>+>Joris Gillis+>+>C++ includes: functor.hpp +-}+newtype Functor = Functor (ForeignPtr Functor')+-- typeclass decl+class FunctorClass a where+ castFunctor :: a -> Functor+instance FunctorClass Functor where+ castFunctor = id++-- baseclass instances+instance SharedObjectClass Functor where+ castSharedObject (Functor x) = SharedObject (castForeignPtr x)++instance PrintableObjectClass Functor where+ castPrintableObject (Functor x) = PrintableObject (castForeignPtr x)+++-- helper instances+instance Marshal Functor (Ptr Functor') where+ withMarshal (Functor x) f = withForeignPtr x f+instance ForeignPtrWrapper Functor Functor' where+ unwrapForeignPtr (Functor x) = x+instance WrapReturn (ForeignPtr Functor') Functor where+ wrapReturn = return . Functor+++-- raw decl+data CustomFunction'+-- data decl+{-|+>Interface to a custom function.+>+>Note: max_number_of_fwd_dir and max_number_of_adj_dir will be default zero+>+>Joel Andersson+>+>>List of available options+>+--------------+--------------+--------------+--------------+--------------++>| Id | Type | Default | Description | Used in |+>+==============+==============+==============+==============+==============++>| ad_mode | OT_STRING | "automatic" | How to | CasADi::FXIn |+>| | | | calculate | ternal |+>| | | | the | |+>| | | | Jacobians. | |+>| | | | (forward: | |+>| | | | only forward | |+>| | | | mode|reverse | |+>| | | | : only | |+>| | | | adjoint mode | |+>| | | | |automatic: | |+>| | | | a heuristic | |+>| | | | decides | |+>| | | | which is | |+>| | | | more | |+>| | | | appropriate) | |+>+--------------+--------------+--------------+--------------+--------------++>| gather_stats | OT_BOOLEAN | false | Flag to | CasADi::FXIn |+>| | | | indicate | ternal |+>| | | | wether | |+>| | | | statistics | |+>| | | | must be | |+>| | | | gathered | |+>+--------------+--------------+--------------+--------------+--------------++>| inputs_check | OT_BOOLEAN | true | Throw | CasADi::FXIn |+>| | | | exceptions | ternal |+>| | | | when the | |+>| | | | numerical | |+>| | | | values of | |+>| | | | the inputs | |+>| | | | don't make | |+>| | | | sense | |+>+--------------+--------------+--------------+--------------+--------------++>| jacobian_gen | OT_JACOBIANG | GenericType( | Function | CasADi::FXIn |+>| erator | ENERATOR | ) | that returns | ternal |+>| | | | a Jacobian | |+>| | | | function | |+>| | | | given a set | |+>| | | | of desired | |+>| | | | Jacobian | |+>| | | | blocks, | |+>| | | | overrides | |+>| | | | internal | |+>| | | | routines. | |+>| | | | Check docume | |+>| | | | ntation of J | |+>| | | | acobianGener | |+>| | | | ator . | |+>+--------------+--------------+--------------+--------------+--------------++>| max_number_o | OT_INTEGER | optimized_nu | Allow "numbe | CasADi::FXIn |+>| f_adj_dir | | m_dir | r_of_adj_dir | ternal |+>| | | | " to grow | |+>| | | | until it | |+>| | | | reaches this | |+>| | | | number | |+>+--------------+--------------+--------------+--------------+--------------++>| max_number_o | OT_INTEGER | optimized_nu | Allow "numbe | CasADi::FXIn |+>| f_fwd_dir | | m_dir | r_of_fwd_dir | ternal |+>| | | | " to grow | |+>| | | | until it | |+>| | | | reaches this | |+>| | | | number | |+>+--------------+--------------+--------------+--------------+--------------++>| monitor | OT_STRINGVEC | GenericType( | Monitors to | CasADi::FXIn |+>| | TOR | ) | be activated | ternal |+>| | | | (inputs|outp | |+>| | | | uts) | |+>+--------------+--------------+--------------+--------------+--------------++>| name | OT_STRING | "unnamed_sha | name of the | CasADi::Opti |+>| | | red_object" | object | onsFunctiona |+>| | | | | lityNode |+>+--------------+--------------+--------------+--------------+--------------++>| number_of_ad | OT_INTEGER | 1 | number of | CasADi::FXIn |+>| j_dir | | | adjoint | ternal |+>| | | | derivatives | |+>| | | | to be | |+>| | | | calculated s | |+>| | | | imultanously | |+>+--------------+--------------+--------------+--------------+--------------++>| number_of_fw | OT_INTEGER | 1 | number of | CasADi::FXIn |+>| d_dir | | | forward | ternal |+>| | | | derivatives | |+>| | | | to be | |+>| | | | calculated s | |+>| | | | imultanously | |+>+--------------+--------------+--------------+--------------+--------------++>| numeric_hess | OT_BOOLEAN | false | Calculate | CasADi::FXIn |+>| ian | | | Hessians | ternal |+>| | | | numerically | |+>| | | | (using | |+>| | | | directional | |+>| | | | derivatives) | |+>| | | | rather than | |+>| | | | with the | |+>| | | | built-in | |+>| | | | method | |+>+--------------+--------------+--------------+--------------+--------------++>| numeric_jaco | OT_BOOLEAN | false | Calculate | CasADi::FXIn |+>| bian | | | Jacobians | ternal |+>| | | | numerically | |+>| | | | (using | |+>| | | | directional | |+>| | | | derivatives) | |+>| | | | rather than | |+>| | | | with the | |+>| | | | built-in | |+>| | | | method | |+>+--------------+--------------+--------------+--------------+--------------++>| regularity_c | OT_BOOLEAN | true | Throw | CasADi::FXIn |+>| heck | | | exceptions | ternal |+>| | | | when NaN or | |+>| | | | Inf appears | |+>| | | | during | |+>| | | | evaluation | |+>+--------------+--------------+--------------+--------------+--------------++>| sparse | OT_BOOLEAN | true | function is | CasADi::FXIn |+>| | | | sparse | ternal |+>+--------------+--------------+--------------+--------------+--------------++>| sparsity_gen | OT_SPARSITYG | GenericType( | Function | CasADi::FXIn |+>| erator | ENERATOR | ) | that | ternal |+>| | | | provides | |+>| | | | sparsity for | |+>| | | | a given | |+>| | | | input output | |+>| | | | block, | |+>| | | | overrides | |+>| | | | internal | |+>| | | | routines. | |+>| | | | Check docume | |+>| | | | ntation of S | |+>| | | | parsityGener | |+>| | | | ator . | |+>+--------------+--------------+--------------+--------------+--------------++>| store_jacobi | OT_BOOLEAN | false | keep | CasADi::FXIn |+>| ans | | | references | ternal |+>| | | | to generated | |+>| | | | Jacobians in | |+>| | | | order to | |+>| | | | avoid | |+>| | | | generating | |+>| | | | identical | |+>| | | | Jacobians | |+>| | | | multiple | |+>| | | | times | |+>+--------------+--------------+--------------+--------------+--------------++>| user_data | OT_VOIDPTR | GenericType( | A user- | CasADi::FXIn |+>| | | ) | defined | ternal |+>| | | | field that | |+>| | | | can be used | |+>| | | | to identify | |+>| | | | the function | |+>| | | | or pass | |+>| | | | additional | |+>| | | | information | |+>+--------------+--------------+--------------+--------------+--------------++>| verbose | OT_BOOLEAN | false | verbose | CasADi::FXIn |+>| | | | evaluation | ternal |+>| | | | for | |+>| | | | debugging | |+>+--------------+--------------+--------------+--------------+--------------++>+>Diagrams+>+>C++ includes: custom_function.hpp +-}+newtype CustomFunction = CustomFunction (ForeignPtr CustomFunction')+-- typeclass decl+class CustomFunctionClass a where+ castCustomFunction :: a -> CustomFunction+instance CustomFunctionClass CustomFunction where+ castCustomFunction = id++-- baseclass instances+instance SharedObjectClass CustomFunction where+ castSharedObject (CustomFunction x) = SharedObject (castForeignPtr x)++instance PrintableObjectClass CustomFunction where+ castPrintableObject (CustomFunction x) = PrintableObject (castForeignPtr x)++instance IOInterfaceFXClass CustomFunction where+ castIOInterfaceFX (CustomFunction x) = IOInterfaceFX (castForeignPtr x)++instance OptionsFunctionalityClass CustomFunction where+ castOptionsFunctionality (CustomFunction x) = OptionsFunctionality (castForeignPtr x)++instance FXClass CustomFunction where+ castFX (CustomFunction x) = FX (castForeignPtr x)+++-- helper instances+instance Marshal CustomFunction (Ptr CustomFunction') where+ withMarshal (CustomFunction x) f = withForeignPtr x f+instance ForeignPtrWrapper CustomFunction CustomFunction' where+ unwrapForeignPtr (CustomFunction x) = x+instance WrapReturn (ForeignPtr CustomFunction') CustomFunction where+ wrapReturn = return . CustomFunction++
+ Casadi/Wrappers/Deleters.hs view
@@ -0,0 +1,249 @@+{-# OPTIONS_GHC -Wall #-}+{-# Language ForeignFunctionInterface #-}++module Casadi.Wrappers.Deleters where++import Foreign.C.Types+import Foreign.Ptr ( FunPtr, Ptr )++import Casadi.Wrappers.Data+import Casadi.MarshalTypes++foreign import ccall unsafe "&delete_std__vector_int_" + c_delete_std__vector_int_ :: FunPtr (Ptr (CppVec CInt) -> IO ())+foreign import ccall unsafe "&delete_std__vector_std__vector_int__" + c_delete_std__vector_std__vector_int__ :: FunPtr (Ptr (CppVecVec CInt) -> IO ())+foreign import ccall unsafe "&delete_std__vector_std__vector_std__vector_int___" + c_delete_std__vector_std__vector_std__vector_int___ :: FunPtr (Ptr (CppVecVecVec CInt) -> IO ())++foreign import ccall unsafe "&delete_std__vector_double_" + c_delete_std__vector_double_ :: FunPtr (Ptr (CppVec CDouble) -> IO ())+foreign import ccall unsafe "&delete_std__vector_std__vector_double__" + c_delete_std__vector_std__vector_double__ :: FunPtr (Ptr (CppVecVec CDouble) -> IO ())+foreign import ccall unsafe "&delete_std__vector_std__vector_std__vector_double___" + c_delete_std__vector_std__vector_std__vector_double___ :: FunPtr (Ptr (CppVecVecVec CDouble) -> IO ())++foreign import ccall unsafe "&delete_std__string" + c_delete_std__string :: FunPtr (Ptr StdString' -> IO ())+foreign import ccall unsafe "&delete_std__vector_std__string_" + c_delete_std__vector_std__string_ :: FunPtr (Ptr (CppVec (Ptr StdString')) -> IO ())+foreign import ccall unsafe "&delete_std__vector_std__vector_std__string__" + c_delete_std__vector_std__vector_std__string__ :: FunPtr (Ptr (CppVecVec (Ptr StdString')) -> IO ())+foreign import ccall unsafe "&delete_std__vector_std__vector_std__vector_std__string___" + c_delete_std__vector_std__vector_std__vector_std__string___ :: FunPtr (Ptr (CppVecVecVec (Ptr StdString')) -> IO ())++foreign import ccall unsafe "&delete_bool" + c_delete_bool :: FunPtr (Ptr CppBool' -> IO ())+foreign import ccall unsafe "&delete_std__vector_bool_" + c_delete_std__vector_bool_ :: FunPtr (Ptr (CppVec (Ptr CppBool')) -> IO ())+foreign import ccall unsafe "&delete_std__vector_std__vector_bool__" + c_delete_std__vector_std__vector_bool__ :: FunPtr (Ptr (CppVecVec (Ptr CppBool')) -> IO ())+foreign import ccall unsafe "&delete_std__vector_std__vector_std__vector_bool___" + c_delete_std__vector_std__vector_std__vector_bool___ :: FunPtr (Ptr (CppVecVecVec (Ptr CppBool')) -> IO ())++foreign import ccall unsafe "&delete_CasADi__SXFunction" + c_delete_CasADi__SXFunction :: FunPtr (Ptr SXFunction' -> IO ())+foreign import ccall unsafe "&delete_std__vector_CasADi__SXFunction_" + c_delete_std__vector_CasADi__SXFunction_ :: FunPtr (Ptr (CppVec (Ptr SXFunction')) -> IO ())+foreign import ccall unsafe "&delete_std__vector_std__vector_CasADi__SXFunction__" + c_delete_std__vector_std__vector_CasADi__SXFunction__ :: FunPtr (Ptr (CppVecVec (Ptr SXFunction')) -> IO ())+foreign import ccall unsafe "&delete_std__vector_std__vector_std__vector_CasADi__SXFunction___" + c_delete_std__vector_std__vector_std__vector_CasADi__SXFunction___ :: FunPtr (Ptr (CppVecVecVec (Ptr SXFunction')) -> IO ())++foreign import ccall unsafe "&delete_CasADi__MXFunction" + c_delete_CasADi__MXFunction :: FunPtr (Ptr MXFunction' -> IO ())+foreign import ccall unsafe "&delete_std__vector_CasADi__MXFunction_" + c_delete_std__vector_CasADi__MXFunction_ :: FunPtr (Ptr (CppVec (Ptr MXFunction')) -> IO ())+foreign import ccall unsafe "&delete_std__vector_std__vector_CasADi__MXFunction__" + c_delete_std__vector_std__vector_CasADi__MXFunction__ :: FunPtr (Ptr (CppVecVec (Ptr MXFunction')) -> IO ())+foreign import ccall unsafe "&delete_std__vector_std__vector_std__vector_CasADi__MXFunction___" + c_delete_std__vector_std__vector_std__vector_CasADi__MXFunction___ :: FunPtr (Ptr (CppVecVecVec (Ptr MXFunction')) -> IO ())++foreign import ccall unsafe "&delete_CasADi__FX" + c_delete_CasADi__FX :: FunPtr (Ptr FX' -> IO ())+foreign import ccall unsafe "&delete_std__vector_CasADi__FX_" + c_delete_std__vector_CasADi__FX_ :: FunPtr (Ptr (CppVec (Ptr FX')) -> IO ())+foreign import ccall unsafe "&delete_std__vector_std__vector_CasADi__FX__" + c_delete_std__vector_std__vector_CasADi__FX__ :: FunPtr (Ptr (CppVecVec (Ptr FX')) -> IO ())+foreign import ccall unsafe "&delete_std__vector_std__vector_std__vector_CasADi__FX___" + c_delete_std__vector_std__vector_std__vector_CasADi__FX___ :: FunPtr (Ptr (CppVecVecVec (Ptr FX')) -> IO ())++foreign import ccall unsafe "&delete_CasADi__SharedObject" + c_delete_CasADi__SharedObject :: FunPtr (Ptr SharedObject' -> IO ())+foreign import ccall unsafe "&delete_std__vector_CasADi__SharedObject_" + c_delete_std__vector_CasADi__SharedObject_ :: FunPtr (Ptr (CppVec (Ptr SharedObject')) -> IO ())+foreign import ccall unsafe "&delete_std__vector_std__vector_CasADi__SharedObject__" + c_delete_std__vector_std__vector_CasADi__SharedObject__ :: FunPtr (Ptr (CppVecVec (Ptr SharedObject')) -> IO ())+foreign import ccall unsafe "&delete_std__vector_std__vector_std__vector_CasADi__SharedObject___" + c_delete_std__vector_std__vector_std__vector_CasADi__SharedObject___ :: FunPtr (Ptr (CppVecVecVec (Ptr SharedObject')) -> IO ())++foreign import ccall unsafe "&delete_CasADi__PrintableObject" + c_delete_CasADi__PrintableObject :: FunPtr (Ptr PrintableObject' -> IO ())+foreign import ccall unsafe "&delete_std__vector_CasADi__PrintableObject_" + c_delete_std__vector_CasADi__PrintableObject_ :: FunPtr (Ptr (CppVec (Ptr PrintableObject')) -> IO ())+foreign import ccall unsafe "&delete_std__vector_std__vector_CasADi__PrintableObject__" + c_delete_std__vector_std__vector_CasADi__PrintableObject__ :: FunPtr (Ptr (CppVecVec (Ptr PrintableObject')) -> IO ())+foreign import ccall unsafe "&delete_std__vector_std__vector_std__vector_CasADi__PrintableObject___" + c_delete_std__vector_std__vector_std__vector_CasADi__PrintableObject___ :: FunPtr (Ptr (CppVecVecVec (Ptr PrintableObject')) -> IO ())++foreign import ccall unsafe "&delete_CasADi__CRSSparsity" + c_delete_CasADi__CRSSparsity :: FunPtr (Ptr CRSSparsity' -> IO ())+foreign import ccall unsafe "&delete_std__vector_CasADi__CRSSparsity_" + c_delete_std__vector_CasADi__CRSSparsity_ :: FunPtr (Ptr (CppVec (Ptr CRSSparsity')) -> IO ())+foreign import ccall unsafe "&delete_std__vector_std__vector_CasADi__CRSSparsity__" + c_delete_std__vector_std__vector_CasADi__CRSSparsity__ :: FunPtr (Ptr (CppVecVec (Ptr CRSSparsity')) -> IO ())+foreign import ccall unsafe "&delete_std__vector_std__vector_std__vector_CasADi__CRSSparsity___" + c_delete_std__vector_std__vector_std__vector_CasADi__CRSSparsity___ :: FunPtr (Ptr (CppVecVecVec (Ptr CRSSparsity')) -> IO ())++foreign import ccall unsafe "&delete_CasADi__GenericType" + c_delete_CasADi__GenericType :: FunPtr (Ptr GenericType' -> IO ())+foreign import ccall unsafe "&delete_std__vector_CasADi__GenericType_" + c_delete_std__vector_CasADi__GenericType_ :: FunPtr (Ptr (CppVec (Ptr GenericType')) -> IO ())+foreign import ccall unsafe "&delete_std__vector_std__vector_CasADi__GenericType__" + c_delete_std__vector_std__vector_CasADi__GenericType__ :: FunPtr (Ptr (CppVecVec (Ptr GenericType')) -> IO ())+foreign import ccall unsafe "&delete_std__vector_std__vector_std__vector_CasADi__GenericType___" + c_delete_std__vector_std__vector_std__vector_CasADi__GenericType___ :: FunPtr (Ptr (CppVecVecVec (Ptr GenericType')) -> IO ())++foreign import ccall unsafe "&delete_CasADi__IOInterface_CasADi__FX_" + c_delete_CasADi__IOInterface_CasADi__FX_ :: FunPtr (Ptr IOInterfaceFX' -> IO ())+foreign import ccall unsafe "&delete_std__vector_CasADi__IOInterface_CasADi__FX__" + c_delete_std__vector_CasADi__IOInterface_CasADi__FX__ :: FunPtr (Ptr (CppVec (Ptr IOInterfaceFX')) -> IO ())+foreign import ccall unsafe "&delete_std__vector_std__vector_CasADi__IOInterface_CasADi__FX___" + c_delete_std__vector_std__vector_CasADi__IOInterface_CasADi__FX___ :: FunPtr (Ptr (CppVecVec (Ptr IOInterfaceFX')) -> IO ())+foreign import ccall unsafe "&delete_std__vector_std__vector_std__vector_CasADi__IOInterface_CasADi__FX____" + c_delete_std__vector_std__vector_std__vector_CasADi__IOInterface_CasADi__FX____ :: FunPtr (Ptr (CppVecVecVec (Ptr IOInterfaceFX')) -> IO ())++foreign import ccall unsafe "&delete_CasADi__OptionsFunctionality" + c_delete_CasADi__OptionsFunctionality :: FunPtr (Ptr OptionsFunctionality' -> IO ())+foreign import ccall unsafe "&delete_std__vector_CasADi__OptionsFunctionality_" + c_delete_std__vector_CasADi__OptionsFunctionality_ :: FunPtr (Ptr (CppVec (Ptr OptionsFunctionality')) -> IO ())+foreign import ccall unsafe "&delete_std__vector_std__vector_CasADi__OptionsFunctionality__" + c_delete_std__vector_std__vector_CasADi__OptionsFunctionality__ :: FunPtr (Ptr (CppVecVec (Ptr OptionsFunctionality')) -> IO ())+foreign import ccall unsafe "&delete_std__vector_std__vector_std__vector_CasADi__OptionsFunctionality___" + c_delete_std__vector_std__vector_std__vector_CasADi__OptionsFunctionality___ :: FunPtr (Ptr (CppVecVecVec (Ptr OptionsFunctionality')) -> IO ())++foreign import ccall unsafe "&delete_CasADi__IpoptSolver" + c_delete_CasADi__IpoptSolver :: FunPtr (Ptr IpoptSolver' -> IO ())+foreign import ccall unsafe "&delete_std__vector_CasADi__IpoptSolver_" + c_delete_std__vector_CasADi__IpoptSolver_ :: FunPtr (Ptr (CppVec (Ptr IpoptSolver')) -> IO ())+foreign import ccall unsafe "&delete_std__vector_std__vector_CasADi__IpoptSolver__" + c_delete_std__vector_std__vector_CasADi__IpoptSolver__ :: FunPtr (Ptr (CppVecVec (Ptr IpoptSolver')) -> IO ())+foreign import ccall unsafe "&delete_std__vector_std__vector_std__vector_CasADi__IpoptSolver___" + c_delete_std__vector_std__vector_std__vector_CasADi__IpoptSolver___ :: FunPtr (Ptr (CppVecVecVec (Ptr IpoptSolver')) -> IO ())++foreign import ccall unsafe "&delete_CasADi__Matrix_CasADi__SX_" + c_delete_CasADi__Matrix_CasADi__SX_ :: FunPtr (Ptr SXMatrix' -> IO ())+foreign import ccall unsafe "&delete_std__vector_CasADi__Matrix_CasADi__SX__" + c_delete_std__vector_CasADi__Matrix_CasADi__SX__ :: FunPtr (Ptr (CppVec (Ptr SXMatrix')) -> IO ())+foreign import ccall unsafe "&delete_std__vector_std__vector_CasADi__Matrix_CasADi__SX___" + c_delete_std__vector_std__vector_CasADi__Matrix_CasADi__SX___ :: FunPtr (Ptr (CppVecVec (Ptr SXMatrix')) -> IO ())+foreign import ccall unsafe "&delete_std__vector_std__vector_std__vector_CasADi__Matrix_CasADi__SX____" + c_delete_std__vector_std__vector_std__vector_CasADi__Matrix_CasADi__SX____ :: FunPtr (Ptr (CppVecVecVec (Ptr SXMatrix')) -> IO ())++foreign import ccall unsafe "&delete_CasADi__IOScheme" + c_delete_CasADi__IOScheme :: FunPtr (Ptr IOScheme' -> IO ())+foreign import ccall unsafe "&delete_std__vector_CasADi__IOScheme_" + c_delete_std__vector_CasADi__IOScheme_ :: FunPtr (Ptr (CppVec (Ptr IOScheme')) -> IO ())+foreign import ccall unsafe "&delete_std__vector_std__vector_CasADi__IOScheme__" + c_delete_std__vector_std__vector_CasADi__IOScheme__ :: FunPtr (Ptr (CppVecVec (Ptr IOScheme')) -> IO ())+foreign import ccall unsafe "&delete_std__vector_std__vector_std__vector_CasADi__IOScheme___" + c_delete_std__vector_std__vector_std__vector_CasADi__IOScheme___ :: FunPtr (Ptr (CppVecVecVec (Ptr IOScheme')) -> IO ())++foreign import ccall unsafe "&delete_CasADi__Matrix_double_" + c_delete_CasADi__Matrix_double_ :: FunPtr (Ptr DMatrix' -> IO ())+foreign import ccall unsafe "&delete_std__vector_CasADi__Matrix_double__" + c_delete_std__vector_CasADi__Matrix_double__ :: FunPtr (Ptr (CppVec (Ptr DMatrix')) -> IO ())+foreign import ccall unsafe "&delete_std__vector_std__vector_CasADi__Matrix_double___" + c_delete_std__vector_std__vector_CasADi__Matrix_double___ :: FunPtr (Ptr (CppVecVec (Ptr DMatrix')) -> IO ())+foreign import ccall unsafe "&delete_std__vector_std__vector_std__vector_CasADi__Matrix_double____" + c_delete_std__vector_std__vector_std__vector_CasADi__Matrix_double____ :: FunPtr (Ptr (CppVecVecVec (Ptr DMatrix')) -> IO ())++foreign import ccall unsafe "&delete_CasADi__MX" + c_delete_CasADi__MX :: FunPtr (Ptr MX' -> IO ())+foreign import ccall unsafe "&delete_std__vector_CasADi__MX_" + c_delete_std__vector_CasADi__MX_ :: FunPtr (Ptr (CppVec (Ptr MX')) -> IO ())+foreign import ccall unsafe "&delete_std__vector_std__vector_CasADi__MX__" + c_delete_std__vector_std__vector_CasADi__MX__ :: FunPtr (Ptr (CppVecVec (Ptr MX')) -> IO ())+foreign import ccall unsafe "&delete_std__vector_std__vector_std__vector_CasADi__MX___" + c_delete_std__vector_std__vector_std__vector_CasADi__MX___ :: FunPtr (Ptr (CppVecVecVec (Ptr MX')) -> IO ())++foreign import ccall unsafe "&delete_CasADi__CasadiOptions" + c_delete_CasADi__CasadiOptions :: FunPtr (Ptr CasadiOptions' -> IO ())+foreign import ccall unsafe "&delete_std__vector_CasADi__CasadiOptions_" + c_delete_std__vector_CasADi__CasadiOptions_ :: FunPtr (Ptr (CppVec (Ptr CasadiOptions')) -> IO ())+foreign import ccall unsafe "&delete_std__vector_std__vector_CasADi__CasadiOptions__" + c_delete_std__vector_std__vector_CasADi__CasadiOptions__ :: FunPtr (Ptr (CppVecVec (Ptr CasadiOptions')) -> IO ())+foreign import ccall unsafe "&delete_std__vector_std__vector_std__vector_CasADi__CasadiOptions___" + c_delete_std__vector_std__vector_std__vector_CasADi__CasadiOptions___ :: FunPtr (Ptr (CppVecVecVec (Ptr CasadiOptions')) -> IO ())++foreign import ccall unsafe "&delete_CasADi__Callback" + c_delete_CasADi__Callback :: FunPtr (Ptr Callback' -> IO ())+foreign import ccall unsafe "&delete_std__vector_CasADi__Callback_" + c_delete_std__vector_CasADi__Callback_ :: FunPtr (Ptr (CppVec (Ptr Callback')) -> IO ())+foreign import ccall unsafe "&delete_std__vector_std__vector_CasADi__Callback__" + c_delete_std__vector_std__vector_CasADi__Callback__ :: FunPtr (Ptr (CppVecVec (Ptr Callback')) -> IO ())+foreign import ccall unsafe "&delete_std__vector_std__vector_std__vector_CasADi__Callback___" + c_delete_std__vector_std__vector_std__vector_CasADi__Callback___ :: FunPtr (Ptr (CppVecVecVec (Ptr Callback')) -> IO ())++foreign import ccall unsafe "&delete_CasADi__CustomEvaluate" + c_delete_CasADi__CustomEvaluate :: FunPtr (Ptr CustomEvaluate' -> IO ())+foreign import ccall unsafe "&delete_std__vector_CasADi__CustomEvaluate_" + c_delete_std__vector_CasADi__CustomEvaluate_ :: FunPtr (Ptr (CppVec (Ptr CustomEvaluate')) -> IO ())+foreign import ccall unsafe "&delete_std__vector_std__vector_CasADi__CustomEvaluate__" + c_delete_std__vector_std__vector_CasADi__CustomEvaluate__ :: FunPtr (Ptr (CppVecVec (Ptr CustomEvaluate')) -> IO ())+foreign import ccall unsafe "&delete_std__vector_std__vector_std__vector_CasADi__CustomEvaluate___" + c_delete_std__vector_std__vector_std__vector_CasADi__CustomEvaluate___ :: FunPtr (Ptr (CppVecVecVec (Ptr CustomEvaluate')) -> IO ())++foreign import ccall unsafe "&delete_CasADi__ExternalFunction" + c_delete_CasADi__ExternalFunction :: FunPtr (Ptr ExternalFunction' -> IO ())+foreign import ccall unsafe "&delete_std__vector_CasADi__ExternalFunction_" + c_delete_std__vector_CasADi__ExternalFunction_ :: FunPtr (Ptr (CppVec (Ptr ExternalFunction')) -> IO ())+foreign import ccall unsafe "&delete_std__vector_std__vector_CasADi__ExternalFunction__" + c_delete_std__vector_std__vector_CasADi__ExternalFunction__ :: FunPtr (Ptr (CppVecVec (Ptr ExternalFunction')) -> IO ())+foreign import ccall unsafe "&delete_std__vector_std__vector_std__vector_CasADi__ExternalFunction___" + c_delete_std__vector_std__vector_std__vector_CasADi__ExternalFunction___ :: FunPtr (Ptr (CppVecVecVec (Ptr ExternalFunction')) -> IO ())++foreign import ccall unsafe "&delete_CasADi__CSparse" + c_delete_CasADi__CSparse :: FunPtr (Ptr CSparse' -> IO ())+foreign import ccall unsafe "&delete_std__vector_CasADi__CSparse_" + c_delete_std__vector_CasADi__CSparse_ :: FunPtr (Ptr (CppVec (Ptr CSparse')) -> IO ())+foreign import ccall unsafe "&delete_std__vector_std__vector_CasADi__CSparse__" + c_delete_std__vector_std__vector_CasADi__CSparse__ :: FunPtr (Ptr (CppVecVec (Ptr CSparse')) -> IO ())+foreign import ccall unsafe "&delete_std__vector_std__vector_std__vector_CasADi__CSparse___" + c_delete_std__vector_std__vector_std__vector_CasADi__CSparse___ :: FunPtr (Ptr (CppVecVecVec (Ptr CSparse')) -> IO ())++foreign import ccall unsafe "&delete_CasADi__SX" + c_delete_CasADi__SX :: FunPtr (Ptr SX' -> IO ())+foreign import ccall unsafe "&delete_std__vector_CasADi__SX_" + c_delete_std__vector_CasADi__SX_ :: FunPtr (Ptr (CppVec (Ptr SX')) -> IO ())+foreign import ccall unsafe "&delete_std__vector_std__vector_CasADi__SX__" + c_delete_std__vector_std__vector_CasADi__SX__ :: FunPtr (Ptr (CppVecVec (Ptr SX')) -> IO ())+foreign import ccall unsafe "&delete_std__vector_std__vector_std__vector_CasADi__SX___" + c_delete_std__vector_std__vector_std__vector_CasADi__SX___ :: FunPtr (Ptr (CppVecVecVec (Ptr SX')) -> IO ())++foreign import ccall unsafe "&delete_CasADi__CasadiMeta" + c_delete_CasADi__CasadiMeta :: FunPtr (Ptr CasadiMeta' -> IO ())+foreign import ccall unsafe "&delete_std__vector_CasADi__CasadiMeta_" + c_delete_std__vector_CasADi__CasadiMeta_ :: FunPtr (Ptr (CppVec (Ptr CasadiMeta')) -> IO ())+foreign import ccall unsafe "&delete_std__vector_std__vector_CasADi__CasadiMeta__" + c_delete_std__vector_std__vector_CasADi__CasadiMeta__ :: FunPtr (Ptr (CppVecVec (Ptr CasadiMeta')) -> IO ())+foreign import ccall unsafe "&delete_std__vector_std__vector_std__vector_CasADi__CasadiMeta___" + c_delete_std__vector_std__vector_std__vector_CasADi__CasadiMeta___ :: FunPtr (Ptr (CppVecVecVec (Ptr CasadiMeta')) -> IO ())++foreign import ccall unsafe "&delete_CasADi__Functor" + c_delete_CasADi__Functor :: FunPtr (Ptr Functor' -> IO ())+foreign import ccall unsafe "&delete_std__vector_CasADi__Functor_" + c_delete_std__vector_CasADi__Functor_ :: FunPtr (Ptr (CppVec (Ptr Functor')) -> IO ())+foreign import ccall unsafe "&delete_std__vector_std__vector_CasADi__Functor__" + c_delete_std__vector_std__vector_CasADi__Functor__ :: FunPtr (Ptr (CppVecVec (Ptr Functor')) -> IO ())+foreign import ccall unsafe "&delete_std__vector_std__vector_std__vector_CasADi__Functor___" + c_delete_std__vector_std__vector_std__vector_CasADi__Functor___ :: FunPtr (Ptr (CppVecVecVec (Ptr Functor')) -> IO ())++foreign import ccall unsafe "&delete_CasADi__CustomFunction" + c_delete_CasADi__CustomFunction :: FunPtr (Ptr CustomFunction' -> IO ())+foreign import ccall unsafe "&delete_std__vector_CasADi__CustomFunction_" + c_delete_std__vector_CasADi__CustomFunction_ :: FunPtr (Ptr (CppVec (Ptr CustomFunction')) -> IO ())+foreign import ccall unsafe "&delete_std__vector_std__vector_CasADi__CustomFunction__" + c_delete_std__vector_std__vector_CasADi__CustomFunction__ :: FunPtr (Ptr (CppVecVec (Ptr CustomFunction')) -> IO ())+foreign import ccall unsafe "&delete_std__vector_std__vector_std__vector_CasADi__CustomFunction___" + c_delete_std__vector_std__vector_std__vector_CasADi__CustomFunction___ :: FunPtr (Ptr (CppVecVecVec (Ptr CustomFunction')) -> IO ())
+ Casadi/Wrappers/Enums.hs view
@@ -0,0 +1,1961 @@+{-# OPTIONS_GHC -Wall #-}+{-# LANGUAGE MultiParamTypeClasses #-}++module Casadi.Wrappers.Enums+ (+ Alias(..),+ Category(..),+ Causality(..),+ CollocationPoints(..),+ ControlSimulatorInput(..),+ ControlledDAEInput(..),+ DAEInput(..),+ DAEOutput(..),+ DPLEInput(..),+ DPLEOutput(..),+ Dynamics(..),+ GradFInput(..),+ GradFOutput(..),+ HessLagInput(..),+ HessLagOutput(..),+ InputOutputScheme(..),+ IntegratorInput(..),+ IntegratorOutput(..),+ JacGInput(..),+ JacGOutput(..),+ LPSolverInput(..),+ LPSolverOutput(..),+ LPStruct(..),+ LinsolInput(..),+ LinsolOutput(..),+ MayerInput(..),+ NLPInput(..),+ NLPOutput(..),+ NLPSolverInput(..),+ NLPSolverOutput(..),+ OCPInput(..),+ OCPOutput(..),+ Operation(..),+ Opt_type(..),+ QCQPSolverInput(..),+ QCQPSolverOutput(..),+ QCQPStruct(..),+ QPSolverInput(..),+ QPSolverOutput(..),+ QPStruct(..),+ RDAEInput(..),+ RDAEOutput(..),+ SDPInput(..),+ SDPOutput(..),+ SDPStruct(..),+ SDQPInput(..),+ SDQPOutput(..),+ SDQPStruct(..),+ SOCPInput(..),+ SOCPOutput(..),+ SOCPStruct(..),+ Sparsity(..),+ StabilizedQPSolverInput(..),+ SymbolicOCPVariables(..),+ Type(..),+ Variability(..),+ ) where+++import Foreign.C.Types ( CInt(..) )+import Casadi.Marshal ( Marshal(..) )+import Casadi.WrapReturn ( WrapReturn(..) )++-- EnumDecl: IntegratorOutput+data IntegratorOutput = INTEGRATOR_ZF+ | INTEGRATOR_XF+ | INTEGRATOR_RQF+ | INTEGRATOR_RXF+ | INTEGRATOR_QF+ | INTEGRATOR_RZF+ | INTEGRATOR_NUM_OUT+ deriving (Show, Eq)+instance Enum IntegratorOutput where+ fromEnum (INTEGRATOR_ZF) = 2+ fromEnum (INTEGRATOR_XF) = 0+ fromEnum (INTEGRATOR_RQF) = 4+ fromEnum (INTEGRATOR_RXF) = 3+ fromEnum (INTEGRATOR_QF) = 1+ fromEnum (INTEGRATOR_RZF) = 5+ fromEnum (INTEGRATOR_NUM_OUT) = 6+ toEnum (2) = INTEGRATOR_ZF+ toEnum (0) = INTEGRATOR_XF+ toEnum (4) = INTEGRATOR_RQF+ toEnum (3) = INTEGRATOR_RXF+ toEnum (1) = INTEGRATOR_QF+ toEnum (5) = INTEGRATOR_RZF+ toEnum (6) = INTEGRATOR_NUM_OUT+ toEnum k+ = error $ "IntegratorOutput: toEnum: got unhandled number: " +++ show k+instance Marshal IntegratorOutput CInt where+ withMarshal x f = f (fromIntegral (fromEnum x))+instance WrapReturn CInt IntegratorOutput where+ wrapReturn = return . toEnum . fromIntegral++-- EnumDecl: Category+data Category = CAT_ALGEBRAIC+ | CAT_UNKNOWN+ | CAT_INDEPENDENT_PARAMETER+ | CAT_DERIVATIVE+ | CAT_DEPENDENT_CONSTANT+ | CAT_INDEPENDENT_CONSTANT+ | CAT_DEPENDENT_PARAMETER+ | CAT_STATE+ deriving (Show, Eq)+instance Enum Category where+ fromEnum (CAT_ALGEBRAIC) = 7+ fromEnum (CAT_UNKNOWN) = 0+ fromEnum (CAT_INDEPENDENT_PARAMETER) = 6+ fromEnum (CAT_DERIVATIVE) = 1+ fromEnum (CAT_DEPENDENT_CONSTANT) = 3+ fromEnum (CAT_INDEPENDENT_CONSTANT) = 4+ fromEnum (CAT_DEPENDENT_PARAMETER) = 5+ fromEnum (CAT_STATE) = 2+ toEnum (7) = CAT_ALGEBRAIC+ toEnum (0) = CAT_UNKNOWN+ toEnum (6) = CAT_INDEPENDENT_PARAMETER+ toEnum (1) = CAT_DERIVATIVE+ toEnum (3) = CAT_DEPENDENT_CONSTANT+ toEnum (4) = CAT_INDEPENDENT_CONSTANT+ toEnum (5) = CAT_DEPENDENT_PARAMETER+ toEnum (2) = CAT_STATE+ toEnum k+ = error $ "Category: toEnum: got unhandled number: " ++ show k+instance Marshal Category CInt where+ withMarshal x f = f (fromIntegral (fromEnum x))+instance WrapReturn CInt Category where+ wrapReturn = return . toEnum . fromIntegral++-- EnumDecl: Causality+data Causality = INPUT+ | INTERNAL+ | OUTPUT+ deriving (Show, Eq)+instance Enum Causality where+ fromEnum (INPUT) = 0+ fromEnum (INTERNAL) = 2+ fromEnum (OUTPUT) = 1+ toEnum (0) = INPUT+ toEnum (2) = INTERNAL+ toEnum (1) = OUTPUT+ toEnum k+ = error $ "Causality: toEnum: got unhandled number: " ++ show k+instance Marshal Causality CInt where+ withMarshal x f = f (fromIntegral (fromEnum x))+instance WrapReturn CInt Causality where+ wrapReturn = return . toEnum . fromIntegral++-- EnumDecl: SDPOutput+data SDPOutput = SDP_SOLVER_LAM_A+ | SDP_SOLVER_DUAL_COST+ | SDP_SOLVER_P+ | SDP_SOLVER_X+ | SDP_SOLVER_NUM_OUT+ | SDP_SOLVER_LAM_X+ | SDP_SOLVER_COST+ | SDP_SOLVER_DUAL+ deriving (Show, Eq)+instance Enum SDPOutput where+ fromEnum (SDP_SOLVER_LAM_A) = 5+ fromEnum (SDP_SOLVER_DUAL_COST) = 4+ fromEnum (SDP_SOLVER_P) = 1+ fromEnum (SDP_SOLVER_X) = 0+ fromEnum (SDP_SOLVER_NUM_OUT) = 7+ fromEnum (SDP_SOLVER_LAM_X) = 6+ fromEnum (SDP_SOLVER_COST) = 3+ fromEnum (SDP_SOLVER_DUAL) = 2+ toEnum (5) = SDP_SOLVER_LAM_A+ toEnum (4) = SDP_SOLVER_DUAL_COST+ toEnum (1) = SDP_SOLVER_P+ toEnum (0) = SDP_SOLVER_X+ toEnum (7) = SDP_SOLVER_NUM_OUT+ toEnum (6) = SDP_SOLVER_LAM_X+ toEnum (3) = SDP_SOLVER_COST+ toEnum (2) = SDP_SOLVER_DUAL+ toEnum k+ = error $ "SDPOutput: toEnum: got unhandled number: " ++ show k+instance Marshal SDPOutput CInt where+ withMarshal x f = f (fromIntegral (fromEnum x))+instance WrapReturn CInt SDPOutput where+ wrapReturn = return . toEnum . fromIntegral++-- EnumDecl: HessLagOutput+data HessLagOutput = HESSLAG_G+ | HESSLAG_F+ | HESSLAG_HESS+ | HESSLAG_NUM_OUT+ | HESSLAG_GRAD_P+ | HESSLAG_GRAD_X+ deriving (Show, Eq)+instance Enum HessLagOutput where+ fromEnum (HESSLAG_G) = 2+ fromEnum (HESSLAG_F) = 1+ fromEnum (HESSLAG_HESS) = 0+ fromEnum (HESSLAG_NUM_OUT) = 5+ fromEnum (HESSLAG_GRAD_P) = 4+ fromEnum (HESSLAG_GRAD_X) = 3+ toEnum (2) = HESSLAG_G+ toEnum (1) = HESSLAG_F+ toEnum (0) = HESSLAG_HESS+ toEnum (5) = HESSLAG_NUM_OUT+ toEnum (4) = HESSLAG_GRAD_P+ toEnum (3) = HESSLAG_GRAD_X+ toEnum k+ = error $ "HessLagOutput: toEnum: got unhandled number: " ++ show k+instance Marshal HessLagOutput CInt where+ withMarshal x f = f (fromIntegral (fromEnum x))+instance WrapReturn CInt HessLagOutput where+ wrapReturn = return . toEnum . fromIntegral++-- EnumDecl: LinsolInput+data LinsolInput = LINSOL_NUM_IN+ | LINSOL_A+ | LINSOL_B+ deriving (Show, Eq)+instance Enum LinsolInput where+ fromEnum (LINSOL_NUM_IN) = 2+ fromEnum (LINSOL_A) = 0+ fromEnum (LINSOL_B) = 1+ toEnum (2) = LINSOL_NUM_IN+ toEnum (0) = LINSOL_A+ toEnum (1) = LINSOL_B+ toEnum k+ = error $ "LinsolInput: toEnum: got unhandled number: " ++ show k+instance Marshal LinsolInput CInt where+ withMarshal x f = f (fromIntegral (fromEnum x))+instance WrapReturn CInt LinsolInput where+ wrapReturn = return . toEnum . fromIntegral++-- EnumDecl: SOCPOutput+data SOCPOutput = SOCP_SOLVER_NUM_OUT+ | SOCP_SOLVER_X+ | SOCP_SOLVER_LAM_X+ | SOCP_SOLVER_COST+ | SOCP_SOLVER_LAM_A+ deriving (Show, Eq)+instance Enum SOCPOutput where+ fromEnum (SOCP_SOLVER_NUM_OUT) = 4+ fromEnum (SOCP_SOLVER_X) = 0+ fromEnum (SOCP_SOLVER_LAM_X) = 3+ fromEnum (SOCP_SOLVER_COST) = 1+ fromEnum (SOCP_SOLVER_LAM_A) = 2+ toEnum (4) = SOCP_SOLVER_NUM_OUT+ toEnum (0) = SOCP_SOLVER_X+ toEnum (3) = SOCP_SOLVER_LAM_X+ toEnum (1) = SOCP_SOLVER_COST+ toEnum (2) = SOCP_SOLVER_LAM_A+ toEnum k+ = error $ "SOCPOutput: toEnum: got unhandled number: " ++ show k+instance Marshal SOCPOutput CInt where+ withMarshal x f = f (fromIntegral (fromEnum x))+instance WrapReturn CInt SOCPOutput where+ wrapReturn = return . toEnum . fromIntegral++-- EnumDecl: LPStruct+data LPStruct = LP_STRUCT_NUM+ | LP_STRUCT_A+ deriving (Show, Eq)+instance Enum LPStruct where+ fromEnum (LP_STRUCT_NUM) = 1+ fromEnum (LP_STRUCT_A) = 0+ toEnum (1) = LP_STRUCT_NUM+ toEnum (0) = LP_STRUCT_A+ toEnum k+ = error $ "LPStruct: toEnum: got unhandled number: " ++ show k+instance Marshal LPStruct CInt where+ withMarshal x f = f (fromIntegral (fromEnum x))+instance WrapReturn CInt LPStruct where+ wrapReturn = return . toEnum . fromIntegral++-- EnumDecl: Opt_type+data Opt_type = OT_CALLBACK+ | OT_VOIDPTR+ | OT_BOOLEAN+ | OT_FX+ | OT_INTEGERVECTOR+ | OT_REALVECTOR+ | OT_LINEARSOLVER+ | OT_BOOLVECTOR+ | OT_STABILIZEDQPSOLVER+ | OT_REAL+ | OT_DERIVATIVEGENERATOR+ | OT_STRING+ | OT_NLPSOLVER+ | OT_LPSOLVER+ | OT_IMPLICITFUNCTION+ | OT_SDQPSOLVER+ | OT_QCQPSOLVER+ | OT_SOCPSOLVER+ | OT_SDPSOLVER+ | OT_INTEGRATOR+ | OT_UNKNOWN+ | OT_STRINGVECTOR+ | OT_INTEGER+ | OT_QPSOLVER+ | OT_DICTIONARY+ deriving (Show, Eq)+instance Enum Opt_type where+ fromEnum (OT_CALLBACK) = 22+ fromEnum (OT_VOIDPTR) = 23+ fromEnum (OT_BOOLEAN) = 0+ fromEnum (OT_FX) = 21+ fromEnum (OT_INTEGERVECTOR) = 4+ fromEnum (OT_REALVECTOR) = 6+ fromEnum (OT_LINEARSOLVER) = 11+ fromEnum (OT_BOOLVECTOR) = 5+ fromEnum (OT_STABILIZEDQPSOLVER) = 14+ fromEnum (OT_REAL) = 2+ fromEnum (OT_DERIVATIVEGENERATOR) = 20+ fromEnum (OT_STRING) = 3+ fromEnum (OT_NLPSOLVER) = 9+ fromEnum (OT_LPSOLVER) = 10+ fromEnum (OT_IMPLICITFUNCTION) = 19+ fromEnum (OT_SDQPSOLVER) = 18+ fromEnum (OT_QCQPSOLVER) = 16+ fromEnum (OT_SOCPSOLVER) = 15+ fromEnum (OT_SDPSOLVER) = 17+ fromEnum (OT_INTEGRATOR) = 12+ fromEnum (OT_UNKNOWN) = 24+ fromEnum (OT_STRINGVECTOR) = 7+ fromEnum (OT_INTEGER) = 1+ fromEnum (OT_QPSOLVER) = 13+ fromEnum (OT_DICTIONARY) = 8+ toEnum (22) = OT_CALLBACK+ toEnum (23) = OT_VOIDPTR+ toEnum (0) = OT_BOOLEAN+ toEnum (21) = OT_FX+ toEnum (4) = OT_INTEGERVECTOR+ toEnum (6) = OT_REALVECTOR+ toEnum (11) = OT_LINEARSOLVER+ toEnum (5) = OT_BOOLVECTOR+ toEnum (14) = OT_STABILIZEDQPSOLVER+ toEnum (2) = OT_REAL+ toEnum (20) = OT_DERIVATIVEGENERATOR+ toEnum (3) = OT_STRING+ toEnum (9) = OT_NLPSOLVER+ toEnum (10) = OT_LPSOLVER+ toEnum (19) = OT_IMPLICITFUNCTION+ toEnum (18) = OT_SDQPSOLVER+ toEnum (16) = OT_QCQPSOLVER+ toEnum (15) = OT_SOCPSOLVER+ toEnum (17) = OT_SDPSOLVER+ toEnum (12) = OT_INTEGRATOR+ toEnum (24) = OT_UNKNOWN+ toEnum (7) = OT_STRINGVECTOR+ toEnum (1) = OT_INTEGER+ toEnum (13) = OT_QPSOLVER+ toEnum (8) = OT_DICTIONARY+ toEnum k+ = error $ "Opt_type: toEnum: got unhandled number: " ++ show k+instance Marshal Opt_type CInt where+ withMarshal x f = f (fromIntegral (fromEnum x))+instance WrapReturn CInt Opt_type where+ wrapReturn = return . toEnum . fromIntegral++-- EnumDecl: SDPInput+data SDPInput = SDP_SOLVER_UBX+ | SDP_SOLVER_NUM_IN+ | SDP_SOLVER_F+ | SDP_SOLVER_G+ | SDP_SOLVER_C+ | SDP_SOLVER_LBX+ | SDP_SOLVER_A+ | SDP_SOLVER_LBA+ | SDP_SOLVER_UBA+ deriving (Show, Eq)+instance Enum SDPInput where+ fromEnum (SDP_SOLVER_UBX) = 7+ fromEnum (SDP_SOLVER_NUM_IN) = 8+ fromEnum (SDP_SOLVER_F) = 0+ fromEnum (SDP_SOLVER_G) = 2+ fromEnum (SDP_SOLVER_C) = 1+ fromEnum (SDP_SOLVER_LBX) = 6+ fromEnum (SDP_SOLVER_A) = 3+ fromEnum (SDP_SOLVER_LBA) = 4+ fromEnum (SDP_SOLVER_UBA) = 5+ toEnum (7) = SDP_SOLVER_UBX+ toEnum (8) = SDP_SOLVER_NUM_IN+ toEnum (0) = SDP_SOLVER_F+ toEnum (2) = SDP_SOLVER_G+ toEnum (1) = SDP_SOLVER_C+ toEnum (6) = SDP_SOLVER_LBX+ toEnum (3) = SDP_SOLVER_A+ toEnum (4) = SDP_SOLVER_LBA+ toEnum (5) = SDP_SOLVER_UBA+ toEnum k+ = error $ "SDPInput: toEnum: got unhandled number: " ++ show k+instance Marshal SDPInput CInt where+ withMarshal x f = f (fromIntegral (fromEnum x))+instance WrapReturn CInt SDPInput where+ wrapReturn = return . toEnum . fromIntegral++-- EnumDecl: LPSolverInput+data LPSolverInput = LP_SOLVER_UBX+ | LP_SOLVER_LBX+ | LP_SOLVER_NUM_IN+ | LP_SOLVER_A+ | LP_SOLVER_C+ | LP_SOLVER_UBA+ | LP_SOLVER_LBA+ deriving (Show, Eq)+instance Enum LPSolverInput where+ fromEnum (LP_SOLVER_UBX) = 5+ fromEnum (LP_SOLVER_LBX) = 4+ fromEnum (LP_SOLVER_NUM_IN) = 6+ fromEnum (LP_SOLVER_A) = 1+ fromEnum (LP_SOLVER_C) = 0+ fromEnum (LP_SOLVER_UBA) = 3+ fromEnum (LP_SOLVER_LBA) = 2+ toEnum (5) = LP_SOLVER_UBX+ toEnum (4) = LP_SOLVER_LBX+ toEnum (6) = LP_SOLVER_NUM_IN+ toEnum (1) = LP_SOLVER_A+ toEnum (0) = LP_SOLVER_C+ toEnum (3) = LP_SOLVER_UBA+ toEnum (2) = LP_SOLVER_LBA+ toEnum k+ = error $ "LPSolverInput: toEnum: got unhandled number: " ++ show k+instance Marshal LPSolverInput CInt where+ withMarshal x f = f (fromIntegral (fromEnum x))+instance WrapReturn CInt LPSolverInput where+ wrapReturn = return . toEnum . fromIntegral++-- EnumDecl: RDAEInput+data RDAEInput = RDAE_Z+ | RDAE_X+ | RDAE_NUM_IN+ | RDAE_P+ | RDAE_T+ | RDAE_RZ+ | RDAE_RX+ | RDAE_RP+ deriving (Show, Eq)+instance Enum RDAEInput where+ fromEnum (RDAE_Z) = 4+ fromEnum (RDAE_X) = 3+ fromEnum (RDAE_NUM_IN) = 7+ fromEnum (RDAE_P) = 5+ fromEnum (RDAE_T) = 6+ fromEnum (RDAE_RZ) = 1+ fromEnum (RDAE_RX) = 0+ fromEnum (RDAE_RP) = 2+ toEnum (4) = RDAE_Z+ toEnum (3) = RDAE_X+ toEnum (7) = RDAE_NUM_IN+ toEnum (5) = RDAE_P+ toEnum (6) = RDAE_T+ toEnum (1) = RDAE_RZ+ toEnum (0) = RDAE_RX+ toEnum (2) = RDAE_RP+ toEnum k+ = error $ "RDAEInput: toEnum: got unhandled number: " ++ show k+instance Marshal RDAEInput CInt where+ withMarshal x f = f (fromIntegral (fromEnum x))+instance WrapReturn CInt RDAEInput where+ wrapReturn = return . toEnum . fromIntegral++-- EnumDecl: NLPSolverOutput+data NLPSolverOutput = NLP_SOLVER_LAM_X+ | NLP_SOLVER_X+ | NLP_SOLVER_LAM_P+ | NLP_SOLVER_G+ | NLP_SOLVER_F+ | NLP_SOLVER_NUM_OUT+ | NLP_SOLVER_LAM_G+ deriving (Show, Eq)+instance Enum NLPSolverOutput where+ fromEnum (NLP_SOLVER_LAM_X) = 3+ fromEnum (NLP_SOLVER_X) = 0+ fromEnum (NLP_SOLVER_LAM_P) = 5+ fromEnum (NLP_SOLVER_G) = 2+ fromEnum (NLP_SOLVER_F) = 1+ fromEnum (NLP_SOLVER_NUM_OUT) = 6+ fromEnum (NLP_SOLVER_LAM_G) = 4+ toEnum (3) = NLP_SOLVER_LAM_X+ toEnum (0) = NLP_SOLVER_X+ toEnum (5) = NLP_SOLVER_LAM_P+ toEnum (2) = NLP_SOLVER_G+ toEnum (1) = NLP_SOLVER_F+ toEnum (6) = NLP_SOLVER_NUM_OUT+ toEnum (4) = NLP_SOLVER_LAM_G+ toEnum k+ = error $ "NLPSolverOutput: toEnum: got unhandled number: " +++ show k+instance Marshal NLPSolverOutput CInt where+ withMarshal x f = f (fromIntegral (fromEnum x))+instance WrapReturn CInt NLPSolverOutput where+ wrapReturn = return . toEnum . fromIntegral++-- EnumDecl: SymbolicOCPVariables+data SymbolicOCPVariables = VAR_PI+ | NUM_VAR+ | VAR_PD+ | VAR_PF+ | VAR_CI+ | VAR_Z+ | VAR_Y+ | VAR_X+ | VAR_CD+ | VAR_U+ | VAR_Q+ deriving (Show, Eq)+instance Enum SymbolicOCPVariables where+ fromEnum (VAR_PI) = 5+ fromEnum (NUM_VAR) = 10+ fromEnum (VAR_PD) = 6+ fromEnum (VAR_PF) = 7+ fromEnum (VAR_CI) = 3+ fromEnum (VAR_Z) = 1+ fromEnum (VAR_Y) = 8+ fromEnum (VAR_X) = 0+ fromEnum (VAR_CD) = 4+ fromEnum (VAR_U) = 9+ fromEnum (VAR_Q) = 2+ toEnum (5) = VAR_PI+ toEnum (10) = NUM_VAR+ toEnum (6) = VAR_PD+ toEnum (7) = VAR_PF+ toEnum (3) = VAR_CI+ toEnum (1) = VAR_Z+ toEnum (8) = VAR_Y+ toEnum (0) = VAR_X+ toEnum (4) = VAR_CD+ toEnum (9) = VAR_U+ toEnum (2) = VAR_Q+ toEnum k+ = error $ "SymbolicOCPVariables: toEnum: got unhandled number: " +++ show k+instance Marshal SymbolicOCPVariables CInt where+ withMarshal x f = f (fromIntegral (fromEnum x))+instance WrapReturn CInt SymbolicOCPVariables where+ wrapReturn = return . toEnum . fromIntegral++-- EnumDecl: DAEOutput+data DAEOutput = DAE_NUM_OUT+ | DAE_ODE+ | DAE_QUAD+ | DAE_ALG+ deriving (Show, Eq)+instance Enum DAEOutput where+ fromEnum (DAE_NUM_OUT) = 3+ fromEnum (DAE_ODE) = 0+ fromEnum (DAE_QUAD) = 2+ fromEnum (DAE_ALG) = 1+ toEnum (3) = DAE_NUM_OUT+ toEnum (0) = DAE_ODE+ toEnum (2) = DAE_QUAD+ toEnum (1) = DAE_ALG+ toEnum k+ = error $ "DAEOutput: toEnum: got unhandled number: " ++ show k+instance Marshal DAEOutput CInt where+ withMarshal x f = f (fromIntegral (fromEnum x))+instance WrapReturn CInt DAEOutput where+ wrapReturn = return . toEnum . fromIntegral++-- EnumDecl: Dynamics+data Dynamics = ALGEBRAIC+ | DIFFERENTIAL+ deriving (Show, Eq)+instance Enum Dynamics where+ fromEnum (ALGEBRAIC) = 0+ fromEnum (DIFFERENTIAL) = 1+ toEnum (0) = ALGEBRAIC+ toEnum (1) = DIFFERENTIAL+ toEnum k+ = error $ "Dynamics: toEnum: got unhandled number: " ++ show k+instance Marshal Dynamics CInt where+ withMarshal x f = f (fromIntegral (fromEnum x))+instance WrapReturn CInt Dynamics where+ wrapReturn = return . toEnum . fromIntegral++-- EnumDecl: SOCPInput+data SOCPInput = SOCP_SOLVER_NUM_IN+ | SOCP_SOLVER_H+ | SOCP_SOLVER_UBX+ | SOCP_SOLVER_C+ | SOCP_SOLVER_A+ | SOCP_SOLVER_G+ | SOCP_SOLVER_F+ | SOCP_SOLVER_E+ | SOCP_SOLVER_LBX+ | SOCP_SOLVER_LBA+ | SOCP_SOLVER_UBA+ deriving (Show, Eq)+instance Enum SOCPInput where+ fromEnum (SOCP_SOLVER_NUM_IN) = 10+ fromEnum (SOCP_SOLVER_H) = 1+ fromEnum (SOCP_SOLVER_UBX) = 9+ fromEnum (SOCP_SOLVER_C) = 4+ fromEnum (SOCP_SOLVER_A) = 5+ fromEnum (SOCP_SOLVER_G) = 0+ fromEnum (SOCP_SOLVER_F) = 3+ fromEnum (SOCP_SOLVER_E) = 2+ fromEnum (SOCP_SOLVER_LBX) = 8+ fromEnum (SOCP_SOLVER_LBA) = 6+ fromEnum (SOCP_SOLVER_UBA) = 7+ toEnum (10) = SOCP_SOLVER_NUM_IN+ toEnum (1) = SOCP_SOLVER_H+ toEnum (9) = SOCP_SOLVER_UBX+ toEnum (4) = SOCP_SOLVER_C+ toEnum (5) = SOCP_SOLVER_A+ toEnum (0) = SOCP_SOLVER_G+ toEnum (3) = SOCP_SOLVER_F+ toEnum (2) = SOCP_SOLVER_E+ toEnum (8) = SOCP_SOLVER_LBX+ toEnum (6) = SOCP_SOLVER_LBA+ toEnum (7) = SOCP_SOLVER_UBA+ toEnum k+ = error $ "SOCPInput: toEnum: got unhandled number: " ++ show k+instance Marshal SOCPInput CInt where+ withMarshal x f = f (fromIntegral (fromEnum x))+instance WrapReturn CInt SOCPInput where+ wrapReturn = return . toEnum . fromIntegral++-- EnumDecl: QCQPSolverInput+data QCQPSolverInput = QCQP_SOLVER_NUM_IN+ | QCQP_SOLVER_H+ | QCQP_SOLVER_X0+ | QCQP_SOLVER_UBX+ | QCQP_SOLVER_A+ | QCQP_SOLVER_G+ | QCQP_SOLVER_LAM_X0+ | QCQP_SOLVER_LBX+ | QCQP_SOLVER_R+ | QCQP_SOLVER_Q+ | QCQP_SOLVER_P+ | QCQP_SOLVER_LBA+ | QCQP_SOLVER_UBA+ deriving (Show, Eq)+instance Enum QCQPSolverInput where+ fromEnum (QCQP_SOLVER_NUM_IN) = 12+ fromEnum (QCQP_SOLVER_H) = 0+ fromEnum (QCQP_SOLVER_X0) = 10+ fromEnum (QCQP_SOLVER_UBX) = 9+ fromEnum (QCQP_SOLVER_A) = 5+ fromEnum (QCQP_SOLVER_G) = 1+ fromEnum (QCQP_SOLVER_LAM_X0) = 11+ fromEnum (QCQP_SOLVER_LBX) = 8+ fromEnum (QCQP_SOLVER_R) = 4+ fromEnum (QCQP_SOLVER_Q) = 3+ fromEnum (QCQP_SOLVER_P) = 2+ fromEnum (QCQP_SOLVER_LBA) = 6+ fromEnum (QCQP_SOLVER_UBA) = 7+ toEnum (12) = QCQP_SOLVER_NUM_IN+ toEnum (0) = QCQP_SOLVER_H+ toEnum (10) = QCQP_SOLVER_X0+ toEnum (9) = QCQP_SOLVER_UBX+ toEnum (5) = QCQP_SOLVER_A+ toEnum (1) = QCQP_SOLVER_G+ toEnum (11) = QCQP_SOLVER_LAM_X0+ toEnum (8) = QCQP_SOLVER_LBX+ toEnum (4) = QCQP_SOLVER_R+ toEnum (3) = QCQP_SOLVER_Q+ toEnum (2) = QCQP_SOLVER_P+ toEnum (6) = QCQP_SOLVER_LBA+ toEnum (7) = QCQP_SOLVER_UBA+ toEnum k+ = error $ "QCQPSolverInput: toEnum: got unhandled number: " +++ show k+instance Marshal QCQPSolverInput CInt where+ withMarshal x f = f (fromIntegral (fromEnum x))+instance WrapReturn CInt QCQPSolverInput where+ wrapReturn = return . toEnum . fromIntegral++-- EnumDecl: Variability+data Variability = PARAMETER+ | CONTINUOUS+ | CONSTANT+ | DISCRETE+ deriving (Show, Eq)+instance Enum Variability where+ fromEnum (PARAMETER) = 1+ fromEnum (CONTINUOUS) = 3+ fromEnum (CONSTANT) = 0+ fromEnum (DISCRETE) = 2+ toEnum (1) = PARAMETER+ toEnum (3) = CONTINUOUS+ toEnum (0) = CONSTANT+ toEnum (2) = DISCRETE+ toEnum k+ = error $ "Variability: toEnum: got unhandled number: " ++ show k+instance Marshal Variability CInt where+ withMarshal x f = f (fromIntegral (fromEnum x))+instance WrapReturn CInt Variability where+ wrapReturn = return . toEnum . fromIntegral++-- EnumDecl: NLPSolverInput+data NLPSolverInput = NLP_SOLVER_LBX+ | NLP_SOLVER_LAM_X0+ | NLP_SOLVER_UBX+ | NLP_SOLVER_P+ | NLP_SOLVER_NUM_IN+ | NLP_SOLVER_X0+ | NLP_SOLVER_LAM_G0+ | NLP_SOLVER_UBG+ | NLP_SOLVER_LBG+ deriving (Show, Eq)+instance Enum NLPSolverInput where+ fromEnum (NLP_SOLVER_LBX) = 2+ fromEnum (NLP_SOLVER_LAM_X0) = 6+ fromEnum (NLP_SOLVER_UBX) = 3+ fromEnum (NLP_SOLVER_P) = 1+ fromEnum (NLP_SOLVER_NUM_IN) = 8+ fromEnum (NLP_SOLVER_X0) = 0+ fromEnum (NLP_SOLVER_LAM_G0) = 7+ fromEnum (NLP_SOLVER_UBG) = 5+ fromEnum (NLP_SOLVER_LBG) = 4+ toEnum (2) = NLP_SOLVER_LBX+ toEnum (6) = NLP_SOLVER_LAM_X0+ toEnum (3) = NLP_SOLVER_UBX+ toEnum (1) = NLP_SOLVER_P+ toEnum (8) = NLP_SOLVER_NUM_IN+ toEnum (0) = NLP_SOLVER_X0+ toEnum (7) = NLP_SOLVER_LAM_G0+ toEnum (5) = NLP_SOLVER_UBG+ toEnum (4) = NLP_SOLVER_LBG+ toEnum k+ = error $ "NLPSolverInput: toEnum: got unhandled number: " +++ show k+instance Marshal NLPSolverInput CInt where+ withMarshal x f = f (fromIntegral (fromEnum x))+instance WrapReturn CInt NLPSolverInput where+ wrapReturn = return . toEnum . fromIntegral++-- EnumDecl: DAEInput+data DAEInput = DAE_T+ | DAE_Z+ | DAE_P+ | DAE_X+ | DAE_NUM_IN+ deriving (Show, Eq)+instance Enum DAEInput where+ fromEnum (DAE_T) = 3+ fromEnum (DAE_Z) = 1+ fromEnum (DAE_P) = 2+ fromEnum (DAE_X) = 0+ fromEnum (DAE_NUM_IN) = 4+ toEnum (3) = DAE_T+ toEnum (1) = DAE_Z+ toEnum (2) = DAE_P+ toEnum (0) = DAE_X+ toEnum (4) = DAE_NUM_IN+ toEnum k+ = error $ "DAEInput: toEnum: got unhandled number: " ++ show k+instance Marshal DAEInput CInt where+ withMarshal x f = f (fromIntegral (fromEnum x))+instance WrapReturn CInt DAEInput where+ wrapReturn = return . toEnum . fromIntegral++-- EnumDecl: NLPOutput+data NLPOutput = NL_NUM_OUT+ | NL_G+ | NL_F+ deriving (Show, Eq)+instance Enum NLPOutput where+ fromEnum (NL_NUM_OUT) = 2+ fromEnum (NL_G) = 1+ fromEnum (NL_F) = 0+ toEnum (2) = NL_NUM_OUT+ toEnum (1) = NL_G+ toEnum (0) = NL_F+ toEnum k+ = error $ "NLPOutput: toEnum: got unhandled number: " ++ show k+instance Marshal NLPOutput CInt where+ withMarshal x f = f (fromIntegral (fromEnum x))+instance WrapReturn CInt NLPOutput where+ wrapReturn = return . toEnum . fromIntegral++-- EnumDecl: InputOutputScheme+data InputOutputScheme = SCHEME_SDPOutput+ | SCHEME_OCPOutput+ | SCHEME_DAEOutput+ | SCHEME_HessLagInput+ | SCHEME_SDQPInput+ | SCHEME_LinsolInput+ | SCHEME_DAEInput+ | SCHEME_IntegratorOutput+ | SCHEME_IntegratorInput+ | SCHEME_HessLagOutput+ | SCHEME_LPSolverInput+ | SCHEME_JacGOutput+ | SCHEME_SOCPStruct+ | SCHEME_ControlledDAEInput+ | SCHEME_QPStruct+ | SCHEME_QCQPSolverInput+ | SCHEME_ControlSimulatorInput+ | SCHEME_QCQPSolverOutput+ | SCHEME_MayerInput+ | SCHEME_OCPInput+ | SCHEME_QPSolverOutput+ | SCHEME_RDAEOutput+ | SCHEME_NLPOutput+ | SCHEME_SDPInput+ | SCHEME_SOCPOutput+ | SCHEME_SDQPStruct+ | SCHEME_GradFInput+ | SCHEME_NLPInput+ | SCHEME_LPSolverOutput+ | SCHEME_NLPSolverInput+ | SCHEME_RDAEInput+ | SCHEME_QPSolverInput+ | SCHEME_SDPStruct+ | SCHEME_LinsolOutput+ | SCHEME_StabilizedQPSolverInput+ | SCHEME_SOCPInput+ | SCHEME_DPLEInput+ | SCHEME_GradFOutput+ | SCHEME_NLPSolverOutput+ | SCHEME_DPLEOutput+ | SCHEME_LPStruct+ | SCHEME_SDQPOutput+ | SCHEME_QCQPStruct+ | SCHEME_JacGInput+ deriving (Show, Eq)+instance Enum InputOutputScheme where+ fromEnum (SCHEME_SDPOutput) = 35+ fromEnum (SCHEME_OCPOutput) = 27+ fromEnum (SCHEME_DAEOutput) = 5+ fromEnum (SCHEME_HessLagInput) = 21+ fromEnum (SCHEME_SDQPInput) = 37+ fromEnum (SCHEME_LinsolInput) = 10+ fromEnum (SCHEME_DAEInput) = 4+ fromEnum (SCHEME_IntegratorOutput) = 9+ fromEnum (SCHEME_IntegratorInput) = 8+ fromEnum (SCHEME_HessLagOutput) = 22+ fromEnum (SCHEME_LPSolverInput) = 12+ fromEnum (SCHEME_JacGOutput) = 20+ fromEnum (SCHEME_SOCPStruct) = 42+ fromEnum (SCHEME_ControlledDAEInput) = 2+ fromEnum (SCHEME_QPStruct) = 33+ fromEnum (SCHEME_QCQPSolverInput) = 28+ fromEnum (SCHEME_ControlSimulatorInput) = 3+ fromEnum (SCHEME_QCQPSolverOutput) = 29+ fromEnum (SCHEME_MayerInput) = 25+ fromEnum (SCHEME_OCPInput) = 26+ fromEnum (SCHEME_QPSolverOutput) = 32+ fromEnum (SCHEME_RDAEOutput) = 7+ fromEnum (SCHEME_NLPOutput) = 16+ fromEnum (SCHEME_SDPInput) = 34+ fromEnum (SCHEME_SOCPOutput) = 41+ fromEnum (SCHEME_SDQPStruct) = 39+ fromEnum (SCHEME_GradFInput) = 17+ fromEnum (SCHEME_NLPInput) = 15+ fromEnum (SCHEME_LPSolverOutput) = 13+ fromEnum (SCHEME_NLPSolverInput) = 23+ fromEnum (SCHEME_RDAEInput) = 6+ fromEnum (SCHEME_QPSolverInput) = 31+ fromEnum (SCHEME_SDPStruct) = 36+ fromEnum (SCHEME_LinsolOutput) = 11+ fromEnum (SCHEME_StabilizedQPSolverInput) = 43+ fromEnum (SCHEME_SOCPInput) = 40+ fromEnum (SCHEME_DPLEInput) = 0+ fromEnum (SCHEME_GradFOutput) = 18+ fromEnum (SCHEME_NLPSolverOutput) = 24+ fromEnum (SCHEME_DPLEOutput) = 1+ fromEnum (SCHEME_LPStruct) = 14+ fromEnum (SCHEME_SDQPOutput) = 38+ fromEnum (SCHEME_QCQPStruct) = 30+ fromEnum (SCHEME_JacGInput) = 19+ toEnum (35) = SCHEME_SDPOutput+ toEnum (27) = SCHEME_OCPOutput+ toEnum (5) = SCHEME_DAEOutput+ toEnum (21) = SCHEME_HessLagInput+ toEnum (37) = SCHEME_SDQPInput+ toEnum (10) = SCHEME_LinsolInput+ toEnum (4) = SCHEME_DAEInput+ toEnum (9) = SCHEME_IntegratorOutput+ toEnum (8) = SCHEME_IntegratorInput+ toEnum (22) = SCHEME_HessLagOutput+ toEnum (12) = SCHEME_LPSolverInput+ toEnum (20) = SCHEME_JacGOutput+ toEnum (42) = SCHEME_SOCPStruct+ toEnum (2) = SCHEME_ControlledDAEInput+ toEnum (33) = SCHEME_QPStruct+ toEnum (28) = SCHEME_QCQPSolverInput+ toEnum (3) = SCHEME_ControlSimulatorInput+ toEnum (29) = SCHEME_QCQPSolverOutput+ toEnum (25) = SCHEME_MayerInput+ toEnum (26) = SCHEME_OCPInput+ toEnum (32) = SCHEME_QPSolverOutput+ toEnum (7) = SCHEME_RDAEOutput+ toEnum (16) = SCHEME_NLPOutput+ toEnum (34) = SCHEME_SDPInput+ toEnum (41) = SCHEME_SOCPOutput+ toEnum (39) = SCHEME_SDQPStruct+ toEnum (17) = SCHEME_GradFInput+ toEnum (15) = SCHEME_NLPInput+ toEnum (13) = SCHEME_LPSolverOutput+ toEnum (23) = SCHEME_NLPSolverInput+ toEnum (6) = SCHEME_RDAEInput+ toEnum (31) = SCHEME_QPSolverInput+ toEnum (36) = SCHEME_SDPStruct+ toEnum (11) = SCHEME_LinsolOutput+ toEnum (43) = SCHEME_StabilizedQPSolverInput+ toEnum (40) = SCHEME_SOCPInput+ toEnum (0) = SCHEME_DPLEInput+ toEnum (18) = SCHEME_GradFOutput+ toEnum (24) = SCHEME_NLPSolverOutput+ toEnum (1) = SCHEME_DPLEOutput+ toEnum (14) = SCHEME_LPStruct+ toEnum (38) = SCHEME_SDQPOutput+ toEnum (30) = SCHEME_QCQPStruct+ toEnum (19) = SCHEME_JacGInput+ toEnum k+ = error $ "InputOutputScheme: toEnum: got unhandled number: " +++ show k+instance Marshal InputOutputScheme CInt where+ withMarshal x f = f (fromIntegral (fromEnum x))+instance WrapReturn CInt InputOutputScheme where+ wrapReturn = return . toEnum . fromIntegral++-- EnumDecl: StabilizedQPSolverInput+data StabilizedQPSolverInput = STABILIZED_QP_SOLVER_LBA+ | STABILIZED_QP_SOLVER_MUR+ | STABILIZED_QP_SOLVER_NUM_IN+ | STABILIZED_QP_SOLVER_X0+ | STABILIZED_QP_SOLVER_UBA+ | STABILIZED_QP_SOLVER_MU+ | STABILIZED_QP_SOLVER_LAM_X0+ | STABILIZED_QP_SOLVER_G+ | STABILIZED_QP_SOLVER_A+ | STABILIZED_QP_SOLVER_LBX+ | STABILIZED_QP_SOLVER_MUE+ | STABILIZED_QP_SOLVER_H+ | STABILIZED_QP_SOLVER_UBX+ deriving (Show, Eq)+instance Enum StabilizedQPSolverInput where+ fromEnum (STABILIZED_QP_SOLVER_LBA) = 3+ fromEnum (STABILIZED_QP_SOLVER_MUR) = 9+ fromEnum (STABILIZED_QP_SOLVER_NUM_IN) = 12+ fromEnum (STABILIZED_QP_SOLVER_X0) = 7+ fromEnum (STABILIZED_QP_SOLVER_UBA) = 4+ fromEnum (STABILIZED_QP_SOLVER_MU) = 11+ fromEnum (STABILIZED_QP_SOLVER_LAM_X0) = 8+ fromEnum (STABILIZED_QP_SOLVER_G) = 1+ fromEnum (STABILIZED_QP_SOLVER_A) = 2+ fromEnum (STABILIZED_QP_SOLVER_LBX) = 5+ fromEnum (STABILIZED_QP_SOLVER_MUE) = 10+ fromEnum (STABILIZED_QP_SOLVER_H) = 0+ fromEnum (STABILIZED_QP_SOLVER_UBX) = 6+ toEnum (3) = STABILIZED_QP_SOLVER_LBA+ toEnum (9) = STABILIZED_QP_SOLVER_MUR+ toEnum (12) = STABILIZED_QP_SOLVER_NUM_IN+ toEnum (7) = STABILIZED_QP_SOLVER_X0+ toEnum (4) = STABILIZED_QP_SOLVER_UBA+ toEnum (11) = STABILIZED_QP_SOLVER_MU+ toEnum (8) = STABILIZED_QP_SOLVER_LAM_X0+ toEnum (1) = STABILIZED_QP_SOLVER_G+ toEnum (2) = STABILIZED_QP_SOLVER_A+ toEnum (5) = STABILIZED_QP_SOLVER_LBX+ toEnum (10) = STABILIZED_QP_SOLVER_MUE+ toEnum (0) = STABILIZED_QP_SOLVER_H+ toEnum (6) = STABILIZED_QP_SOLVER_UBX+ toEnum k+ = error $ "StabilizedQPSolverInput: toEnum: got unhandled number: "+ ++ show k+instance Marshal StabilizedQPSolverInput CInt where+ withMarshal x f = f (fromIntegral (fromEnum x))+instance WrapReturn CInt StabilizedQPSolverInput where+ wrapReturn = return . toEnum . fromIntegral++-- EnumDecl: GradFInput+data GradFInput = GRADF_X+ | GRADF_P+ | GRADF_NUM_IN+ deriving (Show, Eq)+instance Enum GradFInput where+ fromEnum (GRADF_X) = 0+ fromEnum (GRADF_P) = 1+ fromEnum (GRADF_NUM_IN) = 2+ toEnum (0) = GRADF_X+ toEnum (1) = GRADF_P+ toEnum (2) = GRADF_NUM_IN+ toEnum k+ = error $ "GradFInput: toEnum: got unhandled number: " ++ show k+instance Marshal GradFInput CInt where+ withMarshal x f = f (fromIntegral (fromEnum x))+instance WrapReturn CInt GradFInput where+ wrapReturn = return . toEnum . fromIntegral++-- EnumDecl: LPSolverOutput+data LPSolverOutput = LP_SOLVER_COST+ | LP_SOLVER_NUM_OUT+ | LP_SOLVER_X+ | LP_SOLVER_LAM_A+ | LP_SOLVER_LAM_X+ deriving (Show, Eq)+instance Enum LPSolverOutput where+ fromEnum (LP_SOLVER_COST) = 1+ fromEnum (LP_SOLVER_NUM_OUT) = 4+ fromEnum (LP_SOLVER_X) = 0+ fromEnum (LP_SOLVER_LAM_A) = 2+ fromEnum (LP_SOLVER_LAM_X) = 3+ toEnum (1) = LP_SOLVER_COST+ toEnum (4) = LP_SOLVER_NUM_OUT+ toEnum (0) = LP_SOLVER_X+ toEnum (2) = LP_SOLVER_LAM_A+ toEnum (3) = LP_SOLVER_LAM_X+ toEnum k+ = error $ "LPSolverOutput: toEnum: got unhandled number: " +++ show k+instance Marshal LPSolverOutput CInt where+ withMarshal x f = f (fromIntegral (fromEnum x))+instance WrapReturn CInt LPSolverOutput where+ wrapReturn = return . toEnum . fromIntegral++-- EnumDecl: GradFOutput+data GradFOutput = GRADF_NUM_OUT+ | GRADF_GRAD+ | GRADF_F+ | GRADF_G+ deriving (Show, Eq)+instance Enum GradFOutput where+ fromEnum (GRADF_NUM_OUT) = 3+ fromEnum (GRADF_GRAD) = 0+ fromEnum (GRADF_F) = 1+ fromEnum (GRADF_G) = 2+ toEnum (3) = GRADF_NUM_OUT+ toEnum (0) = GRADF_GRAD+ toEnum (1) = GRADF_F+ toEnum (2) = GRADF_G+ toEnum k+ = error $ "GradFOutput: toEnum: got unhandled number: " ++ show k+instance Marshal GradFOutput CInt where+ withMarshal x f = f (fromIntegral (fromEnum x))+instance WrapReturn CInt GradFOutput where+ wrapReturn = return . toEnum . fromIntegral++-- EnumDecl: SDQPInput+data SDQPInput = SDQP_SOLVER_LBX+ | SDQP_SOLVER_UBX+ | SDQP_SOLVER_UBA+ | SDQP_SOLVER_NUM_IN+ | SDQP_SOLVER_F+ | SDQP_SOLVER_G+ | SDQP_SOLVER_A+ | SDQP_SOLVER_C+ | SDQP_SOLVER_LBA+ | SDQP_SOLVER_H+ deriving (Show, Eq)+instance Enum SDQPInput where+ fromEnum (SDQP_SOLVER_LBX) = 7+ fromEnum (SDQP_SOLVER_UBX) = 8+ fromEnum (SDQP_SOLVER_UBA) = 6+ fromEnum (SDQP_SOLVER_NUM_IN) = 9+ fromEnum (SDQP_SOLVER_F) = 2+ fromEnum (SDQP_SOLVER_G) = 3+ fromEnum (SDQP_SOLVER_A) = 4+ fromEnum (SDQP_SOLVER_C) = 1+ fromEnum (SDQP_SOLVER_LBA) = 5+ fromEnum (SDQP_SOLVER_H) = 0+ toEnum (7) = SDQP_SOLVER_LBX+ toEnum (8) = SDQP_SOLVER_UBX+ toEnum (6) = SDQP_SOLVER_UBA+ toEnum (9) = SDQP_SOLVER_NUM_IN+ toEnum (2) = SDQP_SOLVER_F+ toEnum (3) = SDQP_SOLVER_G+ toEnum (4) = SDQP_SOLVER_A+ toEnum (1) = SDQP_SOLVER_C+ toEnum (5) = SDQP_SOLVER_LBA+ toEnum (0) = SDQP_SOLVER_H+ toEnum k+ = error $ "SDQPInput: toEnum: got unhandled number: " ++ show k+instance Marshal SDQPInput CInt where+ withMarshal x f = f (fromIntegral (fromEnum x))+instance WrapReturn CInt SDQPInput where+ wrapReturn = return . toEnum . fromIntegral++-- EnumDecl: OCPInput+data OCPInput = OCP_LBX+ | OCP_LBH+ | OCP_UBP+ | OCP_LBP+ | OCP_UBU+ | OCP_LBU+ | OCP_UBG+ | OCP_U_INIT+ | OCP_P_INIT+ | OCP_NUM_IN+ | OCP_X_INIT+ | OCP_UBX+ | OCP_LBG+ | OCP_UBH+ deriving (Show, Eq)+instance Enum OCPInput where+ fromEnum (OCP_LBX) = 0+ fromEnum (OCP_LBH) = 9+ fromEnum (OCP_UBP) = 7+ fromEnum (OCP_LBP) = 6+ fromEnum (OCP_UBU) = 4+ fromEnum (OCP_LBU) = 3+ fromEnum (OCP_UBG) = 12+ fromEnum (OCP_U_INIT) = 5+ fromEnum (OCP_P_INIT) = 8+ fromEnum (OCP_NUM_IN) = 13+ fromEnum (OCP_X_INIT) = 2+ fromEnum (OCP_UBX) = 1+ fromEnum (OCP_LBG) = 11+ fromEnum (OCP_UBH) = 10+ toEnum (0) = OCP_LBX+ toEnum (9) = OCP_LBH+ toEnum (7) = OCP_UBP+ toEnum (6) = OCP_LBP+ toEnum (4) = OCP_UBU+ toEnum (3) = OCP_LBU+ toEnum (12) = OCP_UBG+ toEnum (5) = OCP_U_INIT+ toEnum (8) = OCP_P_INIT+ toEnum (13) = OCP_NUM_IN+ toEnum (2) = OCP_X_INIT+ toEnum (1) = OCP_UBX+ toEnum (11) = OCP_LBG+ toEnum (10) = OCP_UBH+ toEnum k+ = error $ "OCPInput: toEnum: got unhandled number: " ++ show k+instance Marshal OCPInput CInt where+ withMarshal x f = f (fromIntegral (fromEnum x))+instance WrapReturn CInt OCPInput where+ wrapReturn = return . toEnum . fromIntegral++-- EnumDecl: CollocationPoints+data CollocationPoints = LEGENDRE+ | RADAU+ deriving (Show, Eq)+instance Enum CollocationPoints where+ fromEnum (LEGENDRE) = 0+ fromEnum (RADAU) = 1+ toEnum (0) = LEGENDRE+ toEnum (1) = RADAU+ toEnum k+ = error $ "CollocationPoints: toEnum: got unhandled number: " +++ show k+instance Marshal CollocationPoints CInt where+ withMarshal x f = f (fromIntegral (fromEnum x))+instance WrapReturn CInt CollocationPoints where+ wrapReturn = return . toEnum . fromIntegral++-- EnumDecl: QCQPSolverOutput+data QCQPSolverOutput = QCQP_SOLVER_NUM_OUT+ | QCQP_SOLVER_X+ | QCQP_SOLVER_LAM_X+ | QCQP_SOLVER_COST+ | QCQP_SOLVER_LAM_A+ deriving (Show, Eq)+instance Enum QCQPSolverOutput where+ fromEnum (QCQP_SOLVER_NUM_OUT) = 4+ fromEnum (QCQP_SOLVER_X) = 0+ fromEnum (QCQP_SOLVER_LAM_X) = 3+ fromEnum (QCQP_SOLVER_COST) = 1+ fromEnum (QCQP_SOLVER_LAM_A) = 2+ toEnum (4) = QCQP_SOLVER_NUM_OUT+ toEnum (0) = QCQP_SOLVER_X+ toEnum (3) = QCQP_SOLVER_LAM_X+ toEnum (1) = QCQP_SOLVER_COST+ toEnum (2) = QCQP_SOLVER_LAM_A+ toEnum k+ = error $ "QCQPSolverOutput: toEnum: got unhandled number: " +++ show k+instance Marshal QCQPSolverOutput CInt where+ withMarshal x f = f (fromIntegral (fromEnum x))+instance WrapReturn CInt QCQPSolverOutput where+ wrapReturn = return . toEnum . fromIntegral++-- EnumDecl: QPStruct+data QPStruct = QP_STRUCT_A+ | QP_STRUCT_H+ | QP_STRUCT_NUM+ deriving (Show, Eq)+instance Enum QPStruct where+ fromEnum (QP_STRUCT_A) = 1+ fromEnum (QP_STRUCT_H) = 0+ fromEnum (QP_STRUCT_NUM) = 2+ toEnum (1) = QP_STRUCT_A+ toEnum (0) = QP_STRUCT_H+ toEnum (2) = QP_STRUCT_NUM+ toEnum k+ = error $ "QPStruct: toEnum: got unhandled number: " ++ show k+instance Marshal QPStruct CInt where+ withMarshal x f = f (fromIntegral (fromEnum x))+instance WrapReturn CInt QPStruct where+ wrapReturn = return . toEnum . fromIntegral++-- EnumDecl: MayerInput+data MayerInput = MAYER_X+ | MAYER_P+ | MAYER_NUM_IN+ deriving (Show, Eq)+instance Enum MayerInput where+ fromEnum (MAYER_X) = 0+ fromEnum (MAYER_P) = 1+ fromEnum (MAYER_NUM_IN) = 2+ toEnum (0) = MAYER_X+ toEnum (1) = MAYER_P+ toEnum (2) = MAYER_NUM_IN+ toEnum k+ = error $ "MayerInput: toEnum: got unhandled number: " ++ show k+instance Marshal MayerInput CInt where+ withMarshal x f = f (fromIntegral (fromEnum x))+instance WrapReturn CInt MayerInput where+ wrapReturn = return . toEnum . fromIntegral++-- EnumDecl: ControlledDAEInput+data ControlledDAEInput = CONTROL_DAE_X+ | CONTROL_DAE_Z+ | CONTROL_DAE_NUM_IN+ | CONTROL_DAE_P+ | CONTROL_DAE_X_MAJOR+ | CONTROL_DAE_TF+ | CONTROL_DAE_T+ | CONTROL_DAE_U+ | CONTROL_DAE_U_INTERP+ | CONTROL_DAE_T0+ deriving (Show, Eq)+instance Enum ControlledDAEInput where+ fromEnum (CONTROL_DAE_X) = 1+ fromEnum (CONTROL_DAE_Z) = 2+ fromEnum (CONTROL_DAE_NUM_IN) = 9+ fromEnum (CONTROL_DAE_P) = 3+ fromEnum (CONTROL_DAE_X_MAJOR) = 6+ fromEnum (CONTROL_DAE_TF) = 8+ fromEnum (CONTROL_DAE_T) = 0+ fromEnum (CONTROL_DAE_U) = 4+ fromEnum (CONTROL_DAE_U_INTERP) = 5+ fromEnum (CONTROL_DAE_T0) = 7+ toEnum (1) = CONTROL_DAE_X+ toEnum (2) = CONTROL_DAE_Z+ toEnum (9) = CONTROL_DAE_NUM_IN+ toEnum (3) = CONTROL_DAE_P+ toEnum (6) = CONTROL_DAE_X_MAJOR+ toEnum (8) = CONTROL_DAE_TF+ toEnum (0) = CONTROL_DAE_T+ toEnum (4) = CONTROL_DAE_U+ toEnum (5) = CONTROL_DAE_U_INTERP+ toEnum (7) = CONTROL_DAE_T0+ toEnum k+ = error $ "ControlledDAEInput: toEnum: got unhandled number: " +++ show k+instance Marshal ControlledDAEInput CInt where+ withMarshal x f = f (fromIntegral (fromEnum x))+instance WrapReturn CInt ControlledDAEInput where+ wrapReturn = return . toEnum . fromIntegral++-- EnumDecl: SDQPStruct+data SDQPStruct = SDQP_STRUCT_NUM+ | SDQP_STRUCT_H+ | SDQP_STRUCT_A+ | SDQP_STRUCT_F+ | SDQP_STRUCT_G+ deriving (Show, Eq)+instance Enum SDQPStruct where+ fromEnum (SDQP_STRUCT_NUM) = 4+ fromEnum (SDQP_STRUCT_H) = 0+ fromEnum (SDQP_STRUCT_A) = 3+ fromEnum (SDQP_STRUCT_F) = 1+ fromEnum (SDQP_STRUCT_G) = 2+ toEnum (4) = SDQP_STRUCT_NUM+ toEnum (0) = SDQP_STRUCT_H+ toEnum (3) = SDQP_STRUCT_A+ toEnum (1) = SDQP_STRUCT_F+ toEnum (2) = SDQP_STRUCT_G+ toEnum k+ = error $ "SDQPStruct: toEnum: got unhandled number: " ++ show k+instance Marshal SDQPStruct CInt where+ withMarshal x f = f (fromIntegral (fromEnum x))+instance WrapReturn CInt SDQPStruct where+ wrapReturn = return . toEnum . fromIntegral++-- EnumDecl: NLPInput+data NLPInput = NL_P+ | NL_NUM_IN+ | NL_X+ deriving (Show, Eq)+instance Enum NLPInput where+ fromEnum (NL_P) = 1+ fromEnum (NL_NUM_IN) = 2+ fromEnum (NL_X) = 0+ toEnum (1) = NL_P+ toEnum (2) = NL_NUM_IN+ toEnum (0) = NL_X+ toEnum k+ = error $ "NLPInput: toEnum: got unhandled number: " ++ show k+instance Marshal NLPInput CInt where+ withMarshal x f = f (fromIntegral (fromEnum x))+instance WrapReturn CInt NLPInput where+ wrapReturn = return . toEnum . fromIntegral++-- EnumDecl: SOCPStruct+data SOCPStruct = SOCP_STRUCT_G+ | SOCP_STRUCT_A+ | SOCP_STRUCT_NUM+ deriving (Show, Eq)+instance Enum SOCPStruct where+ fromEnum (SOCP_STRUCT_G) = 0+ fromEnum (SOCP_STRUCT_A) = 1+ fromEnum (SOCP_STRUCT_NUM) = 2+ toEnum (0) = SOCP_STRUCT_G+ toEnum (1) = SOCP_STRUCT_A+ toEnum (2) = SOCP_STRUCT_NUM+ toEnum k+ = error $ "SOCPStruct: toEnum: got unhandled number: " ++ show k+instance Marshal SOCPStruct CInt where+ withMarshal x f = f (fromIntegral (fromEnum x))+instance WrapReturn CInt SOCPStruct where+ wrapReturn = return . toEnum . fromIntegral++-- EnumDecl: IntegratorInput+data IntegratorInput = INTEGRATOR_RZ0+ | INTEGRATOR_RX0+ | INTEGRATOR_RP+ | INTEGRATOR_NUM_IN+ | INTEGRATOR_X0+ | INTEGRATOR_Z0+ | INTEGRATOR_P+ deriving (Show, Eq)+instance Enum IntegratorInput where+ fromEnum (INTEGRATOR_RZ0) = 5+ fromEnum (INTEGRATOR_RX0) = 3+ fromEnum (INTEGRATOR_RP) = 4+ fromEnum (INTEGRATOR_NUM_IN) = 6+ fromEnum (INTEGRATOR_X0) = 0+ fromEnum (INTEGRATOR_Z0) = 2+ fromEnum (INTEGRATOR_P) = 1+ toEnum (5) = INTEGRATOR_RZ0+ toEnum (3) = INTEGRATOR_RX0+ toEnum (4) = INTEGRATOR_RP+ toEnum (6) = INTEGRATOR_NUM_IN+ toEnum (0) = INTEGRATOR_X0+ toEnum (2) = INTEGRATOR_Z0+ toEnum (1) = INTEGRATOR_P+ toEnum k+ = error $ "IntegratorInput: toEnum: got unhandled number: " +++ show k+instance Marshal IntegratorInput CInt where+ withMarshal x f = f (fromIntegral (fromEnum x))+instance WrapReturn CInt IntegratorInput where+ wrapReturn = return . toEnum . fromIntegral++-- EnumDecl: QPSolverInput+data QPSolverInput = QP_SOLVER_LBA+ | QP_SOLVER_UBA+ | QP_SOLVER_LAM_X0+ | QP_SOLVER_NUM_IN+ | QP_SOLVER_LBX+ | QP_SOLVER_UBX+ | QP_SOLVER_H+ | QP_SOLVER_X0+ | QP_SOLVER_G+ | QP_SOLVER_A+ deriving (Show, Eq)+instance Enum QPSolverInput where+ fromEnum (QP_SOLVER_LBA) = 3+ fromEnum (QP_SOLVER_UBA) = 4+ fromEnum (QP_SOLVER_LAM_X0) = 8+ fromEnum (QP_SOLVER_NUM_IN) = 9+ fromEnum (QP_SOLVER_LBX) = 5+ fromEnum (QP_SOLVER_UBX) = 6+ fromEnum (QP_SOLVER_H) = 0+ fromEnum (QP_SOLVER_X0) = 7+ fromEnum (QP_SOLVER_G) = 1+ fromEnum (QP_SOLVER_A) = 2+ toEnum (3) = QP_SOLVER_LBA+ toEnum (4) = QP_SOLVER_UBA+ toEnum (8) = QP_SOLVER_LAM_X0+ toEnum (9) = QP_SOLVER_NUM_IN+ toEnum (5) = QP_SOLVER_LBX+ toEnum (6) = QP_SOLVER_UBX+ toEnum (0) = QP_SOLVER_H+ toEnum (7) = QP_SOLVER_X0+ toEnum (1) = QP_SOLVER_G+ toEnum (2) = QP_SOLVER_A+ toEnum k+ = error $ "QPSolverInput: toEnum: got unhandled number: " ++ show k+instance Marshal QPSolverInput CInt where+ withMarshal x f = f (fromIntegral (fromEnum x))+instance WrapReturn CInt QPSolverInput where+ wrapReturn = return . toEnum . fromIntegral++-- EnumDecl: Sparsity+data Sparsity = DENSE+ | SPARSESYM+ | DENSESYM+ | SPARSE+ deriving (Show, Eq)+instance Enum Sparsity where+ fromEnum (DENSE) = 2+ fromEnum (SPARSESYM) = 1+ fromEnum (DENSESYM) = 3+ fromEnum (SPARSE) = 0+ toEnum (2) = DENSE+ toEnum (1) = SPARSESYM+ toEnum (3) = DENSESYM+ toEnum (0) = SPARSE+ toEnum k+ = error $ "Sparsity: toEnum: got unhandled number: " ++ show k+instance Marshal Sparsity CInt where+ withMarshal x f = f (fromIntegral (fromEnum x))+instance WrapReturn CInt Sparsity where+ wrapReturn = return . toEnum . fromIntegral++-- EnumDecl: OCPOutput+data OCPOutput = OCP_X_OPT+ | OCP_P_OPT+ | OCP_U_OPT+ | OCP_COST+ | OCP_NUM_OUT+ deriving (Show, Eq)+instance Enum OCPOutput where+ fromEnum (OCP_X_OPT) = 0+ fromEnum (OCP_P_OPT) = 2+ fromEnum (OCP_U_OPT) = 1+ fromEnum (OCP_COST) = 3+ fromEnum (OCP_NUM_OUT) = 4+ toEnum (0) = OCP_X_OPT+ toEnum (2) = OCP_P_OPT+ toEnum (1) = OCP_U_OPT+ toEnum (3) = OCP_COST+ toEnum (4) = OCP_NUM_OUT+ toEnum k+ = error $ "OCPOutput: toEnum: got unhandled number: " ++ show k+instance Marshal OCPOutput CInt where+ withMarshal x f = f (fromIntegral (fromEnum x))+instance WrapReturn CInt OCPOutput where+ wrapReturn = return . toEnum . fromIntegral++-- EnumDecl: RDAEOutput+data RDAEOutput = RDAE_ODE+ | RDAE_NUM_OUT+ | RDAE_QUAD+ | RDAE_ALG+ deriving (Show, Eq)+instance Enum RDAEOutput where+ fromEnum (RDAE_ODE) = 0+ fromEnum (RDAE_NUM_OUT) = 3+ fromEnum (RDAE_QUAD) = 2+ fromEnum (RDAE_ALG) = 1+ toEnum (0) = RDAE_ODE+ toEnum (3) = RDAE_NUM_OUT+ toEnum (2) = RDAE_QUAD+ toEnum (1) = RDAE_ALG+ toEnum k+ = error $ "RDAEOutput: toEnum: got unhandled number: " ++ show k+instance Marshal RDAEOutput CInt where+ withMarshal x f = f (fromIntegral (fromEnum x))+instance WrapReturn CInt RDAEOutput where+ wrapReturn = return . toEnum . fromIntegral++-- EnumDecl: DPLEInput+data DPLEInput = DPLE_V+ | DPLE_NUM_IN+ | DPLE_A+ deriving (Show, Eq)+instance Enum DPLEInput where+ fromEnum (DPLE_V) = 1+ fromEnum (DPLE_NUM_IN) = 2+ fromEnum (DPLE_A) = 0+ toEnum (1) = DPLE_V+ toEnum (2) = DPLE_NUM_IN+ toEnum (0) = DPLE_A+ toEnum k+ = error $ "DPLEInput: toEnum: got unhandled number: " ++ show k+instance Marshal DPLEInput CInt where+ withMarshal x f = f (fromIntegral (fromEnum x))+instance WrapReturn CInt DPLEInput where+ wrapReturn = return . toEnum . fromIntegral++-- EnumDecl: JacGOutput+data JacGOutput = JACG_F+ | JACG_G+ | JACG_JAC+ | JACG_NUM_OUT+ deriving (Show, Eq)+instance Enum JacGOutput where+ fromEnum (JACG_F) = 1+ fromEnum (JACG_G) = 2+ fromEnum (JACG_JAC) = 0+ fromEnum (JACG_NUM_OUT) = 3+ toEnum (1) = JACG_F+ toEnum (2) = JACG_G+ toEnum (0) = JACG_JAC+ toEnum (3) = JACG_NUM_OUT+ toEnum k+ = error $ "JacGOutput: toEnum: got unhandled number: " ++ show k+instance Marshal JacGOutput CInt where+ withMarshal x f = f (fromIntegral (fromEnum x))+instance WrapReturn CInt JacGOutput where+ wrapReturn = return . toEnum . fromIntegral++-- EnumDecl: QCQPStruct+data QCQPStruct = QCQP_STRUCT_NUM+ | QCQP_STRUCT_A+ | QCQP_STRUCT_H+ | QCQP_STRUCT_P+ deriving (Show, Eq)+instance Enum QCQPStruct where+ fromEnum (QCQP_STRUCT_NUM) = 3+ fromEnum (QCQP_STRUCT_A) = 2+ fromEnum (QCQP_STRUCT_H) = 0+ fromEnum (QCQP_STRUCT_P) = 1+ toEnum (3) = QCQP_STRUCT_NUM+ toEnum (2) = QCQP_STRUCT_A+ toEnum (0) = QCQP_STRUCT_H+ toEnum (1) = QCQP_STRUCT_P+ toEnum k+ = error $ "QCQPStruct: toEnum: got unhandled number: " ++ show k+instance Marshal QCQPStruct CInt where+ withMarshal x f = f (fromIntegral (fromEnum x))+instance WrapReturn CInt QCQPStruct where+ wrapReturn = return . toEnum . fromIntegral++-- EnumDecl: LinsolOutput+data LinsolOutput = LINSOL_X+ | LINSOL_NUM_OUT+ deriving (Show, Eq)+instance Enum LinsolOutput where+ fromEnum (LINSOL_X) = 0+ fromEnum (LINSOL_NUM_OUT) = 1+ toEnum (0) = LINSOL_X+ toEnum (1) = LINSOL_NUM_OUT+ toEnum k+ = error $ "LinsolOutput: toEnum: got unhandled number: " ++ show k+instance Marshal LinsolOutput CInt where+ withMarshal x f = f (fromIntegral (fromEnum x))+instance WrapReturn CInt LinsolOutput where+ wrapReturn = return . toEnum . fromIntegral++-- EnumDecl: SDQPOutput+data SDQPOutput = SDQP_SOLVER_P+ | SDQP_SOLVER_LAM_X+ | SDQP_SOLVER_DUAL+ | SDQP_SOLVER_X+ | SDQP_SOLVER_DUAL_COST+ | SDQP_SOLVER_COST+ | SDQP_SOLVER_NUM_OUT+ | SDQP_SOLVER_LAM_A+ deriving (Show, Eq)+instance Enum SDQPOutput where+ fromEnum (SDQP_SOLVER_P) = 1+ fromEnum (SDQP_SOLVER_LAM_X) = 6+ fromEnum (SDQP_SOLVER_DUAL) = 2+ fromEnum (SDQP_SOLVER_X) = 0+ fromEnum (SDQP_SOLVER_DUAL_COST) = 4+ fromEnum (SDQP_SOLVER_COST) = 3+ fromEnum (SDQP_SOLVER_NUM_OUT) = 7+ fromEnum (SDQP_SOLVER_LAM_A) = 5+ toEnum (1) = SDQP_SOLVER_P+ toEnum (6) = SDQP_SOLVER_LAM_X+ toEnum (2) = SDQP_SOLVER_DUAL+ toEnum (0) = SDQP_SOLVER_X+ toEnum (4) = SDQP_SOLVER_DUAL_COST+ toEnum (3) = SDQP_SOLVER_COST+ toEnum (7) = SDQP_SOLVER_NUM_OUT+ toEnum (5) = SDQP_SOLVER_LAM_A+ toEnum k+ = error $ "SDQPOutput: toEnum: got unhandled number: " ++ show k+instance Marshal SDQPOutput CInt where+ withMarshal x f = f (fromIntegral (fromEnum x))+instance WrapReturn CInt SDQPOutput where+ wrapReturn = return . toEnum . fromIntegral++-- EnumDecl: Type+data Type = INT+ | SLICE+ | IVECTOR+ | NILL+ deriving (Show, Eq)+instance Enum Type where+ fromEnum (INT) = 1+ fromEnum (SLICE) = 2+ fromEnum (IVECTOR) = 3+ fromEnum (NILL) = 0+ toEnum (1) = INT+ toEnum (2) = SLICE+ toEnum (3) = IVECTOR+ toEnum (0) = NILL+ toEnum k = error $ "Type: toEnum: got unhandled number: " ++ show k+instance Marshal Type CInt where+ withMarshal x f = f (fromIntegral (fromEnum x))+instance WrapReturn CInt Type where+ wrapReturn = return . toEnum . fromIntegral++-- EnumDecl: ControlSimulatorInput+data ControlSimulatorInput = CONTROLSIMULATOR_X0+ | CONTROLSIMULATOR_NUM_IN+ | CONTROLSIMULATOR_P+ | CONTROLSIMULATOR_U+ deriving (Show, Eq)+instance Enum ControlSimulatorInput where+ fromEnum (CONTROLSIMULATOR_X0) = 0+ fromEnum (CONTROLSIMULATOR_NUM_IN) = 3+ fromEnum (CONTROLSIMULATOR_P) = 1+ fromEnum (CONTROLSIMULATOR_U) = 2+ toEnum (0) = CONTROLSIMULATOR_X0+ toEnum (3) = CONTROLSIMULATOR_NUM_IN+ toEnum (1) = CONTROLSIMULATOR_P+ toEnum (2) = CONTROLSIMULATOR_U+ toEnum k+ = error $ "ControlSimulatorInput: toEnum: got unhandled number: "+ ++ show k+instance Marshal ControlSimulatorInput CInt where+ withMarshal x f = f (fromIntegral (fromEnum x))+instance WrapReturn CInt ControlSimulatorInput where+ wrapReturn = return . toEnum . fromIntegral++-- EnumDecl: Alias+data Alias = ALIAS+ | NO_ALIAS+ | NEGATED_ALIAS+ deriving (Show, Eq)+instance Enum Alias where+ fromEnum (ALIAS) = 1+ fromEnum (NO_ALIAS) = 0+ fromEnum (NEGATED_ALIAS) = 2+ toEnum (1) = ALIAS+ toEnum (0) = NO_ALIAS+ toEnum (2) = NEGATED_ALIAS+ toEnum k+ = error $ "Alias: toEnum: got unhandled number: " ++ show k+instance Marshal Alias CInt where+ withMarshal x f = f (fromIntegral (fromEnum x))+instance WrapReturn CInt Alias where+ wrapReturn = return . toEnum . fromIntegral++-- EnumDecl: SDPStruct+data SDPStruct = SDP_STRUCT_A+ | SDP_STRUCT_NUM+ | SDP_STRUCT_F+ | SDP_STRUCT_G+ deriving (Show, Eq)+instance Enum SDPStruct where+ fromEnum (SDP_STRUCT_A) = 2+ fromEnum (SDP_STRUCT_NUM) = 3+ fromEnum (SDP_STRUCT_F) = 0+ fromEnum (SDP_STRUCT_G) = 1+ toEnum (2) = SDP_STRUCT_A+ toEnum (3) = SDP_STRUCT_NUM+ toEnum (0) = SDP_STRUCT_F+ toEnum (1) = SDP_STRUCT_G+ toEnum k+ = error $ "SDPStruct: toEnum: got unhandled number: " ++ show k+instance Marshal SDPStruct CInt where+ withMarshal x f = f (fromIntegral (fromEnum x))+instance WrapReturn CInt SDPStruct where+ wrapReturn = return . toEnum . fromIntegral++-- EnumDecl: JacGInput+data JacGInput = JACG_NUM_IN+ | JACG_P+ | JACG_X+ deriving (Show, Eq)+instance Enum JacGInput where+ fromEnum (JACG_NUM_IN) = 2+ fromEnum (JACG_P) = 1+ fromEnum (JACG_X) = 0+ toEnum (2) = JACG_NUM_IN+ toEnum (1) = JACG_P+ toEnum (0) = JACG_X+ toEnum k+ = error $ "JacGInput: toEnum: got unhandled number: " ++ show k+instance Marshal JacGInput CInt where+ withMarshal x f = f (fromIntegral (fromEnum x))+instance WrapReturn CInt JacGInput where+ wrapReturn = return . toEnum . fromIntegral++-- EnumDecl: DPLEOutput+data DPLEOutput = DPLE_NUM_OUT+ | DPLE_P+ deriving (Show, Eq)+instance Enum DPLEOutput where+ fromEnum (DPLE_NUM_OUT) = 1+ fromEnum (DPLE_P) = 0+ toEnum (1) = DPLE_NUM_OUT+ toEnum (0) = DPLE_P+ toEnum k+ = error $ "DPLEOutput: toEnum: got unhandled number: " ++ show k+instance Marshal DPLEOutput CInt where+ withMarshal x f = f (fromIntegral (fromEnum x))+instance WrapReturn CInt DPLEOutput where+ wrapReturn = return . toEnum . fromIntegral++-- EnumDecl: HessLagInput+data HessLagInput = HESSLAG_NUM_IN+ | HESSLAG_LAM_G+ | HESSLAG_LAM_F+ | HESSLAG_X+ | HESSLAG_P+ deriving (Show, Eq)+instance Enum HessLagInput where+ fromEnum (HESSLAG_NUM_IN) = 4+ fromEnum (HESSLAG_LAM_G) = 3+ fromEnum (HESSLAG_LAM_F) = 2+ fromEnum (HESSLAG_X) = 0+ fromEnum (HESSLAG_P) = 1+ toEnum (4) = HESSLAG_NUM_IN+ toEnum (3) = HESSLAG_LAM_G+ toEnum (2) = HESSLAG_LAM_F+ toEnum (0) = HESSLAG_X+ toEnum (1) = HESSLAG_P+ toEnum k+ = error $ "HessLagInput: toEnum: got unhandled number: " ++ show k+instance Marshal HessLagInput CInt where+ withMarshal x f = f (fromIntegral (fromEnum x))+instance WrapReturn CInt HessLagInput where+ wrapReturn = return . toEnum . fromIntegral++-- EnumDecl: Operation+data Operation = OP_SETNONZEROS+ | OP_FLOOR+ | OP_TAN+ | OP_NORMINF+ | OP_ERFINV+ | OP_FABS+ | OP_LT+ | OP_LIFT+ | OP_DETERMINANT+ | OP_SIN+ | OP_PARAMETER+ | OP_TANH+ | OP_MUL+ | OP_NOT+ | OP_IF_ELSE_ZERO+ | OP_PRINTME+ | OP_ERF+ | OP_LE+ | OP_CALL+ | OP_SOLVE+ | OP_NE+ | OP_NORM1+ | OP_CONSTPOW+ | OP_DIV+ | OP_RESHAPE+ | OP_INV+ | OP_NORM2+ | OP_AND+ | OP_COS+ | OP_GETNONZEROS+ | OP_FMAX+ | OP_CEIL+ | OP_POW+ | OP_INVERSE+ | OP_CONST+ | OP_LOG+ | OP_NEG+ | OP_SUBASSIGN+ | OP_ATAN+ | OP_SQRT+ | OP_ASSERTION+ | OP_VERTSPLIT+ | OP_ASINH+ | OP_COSH+ | OP_ASSIGN+ | OP_FMIN+ | OP_ADD+ | OP_SINH+ | OP_SUB+ | OP_SIGN+ | OP_SQ+ | OP_NORMF+ | OP_ACOSH+ | OP_EXP+ | OP_INPUT+ | OP_OUTPUT+ | OP_VERTCAT+ | OP_EQ+ | OP_INNER_PROD+ | OP_MATMUL+ | OP_TRANSPOSE+ | OP_ASIN+ | OP_COPYSIGN+ | OP_ATANH+ | NUM_BUILT_IN_OPS+ | OP_ACOS+ | OP_OR+ | OP_TWICE+ | OP_SUBREF+ | OP_ATAN2+ | OP_SET_SPARSE+ | OP_ADDNONZEROS+ deriving (Show, Eq)+instance Enum Operation where+ fromEnum (OP_SETNONZEROS) = 61+ fromEnum (OP_FLOOR) = 26+ fromEnum (OP_TAN) = 15+ fromEnum (OP_NORMINF) = 66+ fromEnum (OP_ERFINV) = 68+ fromEnum (OP_FABS) = 28+ fromEnum (OP_LT) = 19+ fromEnum (OP_LIFT) = 70+ fromEnum (OP_DETERMINANT) = 51+ fromEnum (OP_SIN) = 13+ fromEnum (OP_PARAMETER) = 46+ fromEnum (OP_TANH) = 38+ fromEnum (OP_MUL) = 3+ fromEnum (OP_NOT) = 23+ fromEnum (OP_IF_ELSE_ZERO) = 31+ fromEnum (OP_PRINTME) = 69+ fromEnum (OP_ERF) = 32+ fromEnum (OP_LE) = 20+ fromEnum (OP_CALL) = 47+ fromEnum (OP_SOLVE) = 49+ fromEnum (OP_NE) = 22+ fromEnum (OP_NORM1) = 65+ fromEnum (OP_CONSTPOW) = 9+ fromEnum (OP_DIV) = 4+ fromEnum (OP_RESHAPE) = 56+ fromEnum (OP_INV) = 35+ fromEnum (OP_NORM2) = 64+ fromEnum (OP_AND) = 24+ fromEnum (OP_COS) = 14+ fromEnum (OP_GETNONZEROS) = 59+ fromEnum (OP_FMAX) = 34+ fromEnum (OP_CEIL) = 27+ fromEnum (OP_POW) = 8+ fromEnum (OP_INVERSE) = 52+ fromEnum (OP_CONST) = 43+ fromEnum (OP_LOG) = 7+ fromEnum (OP_NEG) = 5+ fromEnum (OP_SUBASSIGN) = 58+ fromEnum (OP_ATAN) = 18+ fromEnum (OP_SQRT) = 10+ fromEnum (OP_ASSERTION) = 63+ fromEnum (OP_VERTSPLIT) = 55+ fromEnum (OP_ASINH) = 39+ fromEnum (OP_COSH) = 37+ fromEnum (OP_ASSIGN) = 0+ fromEnum (OP_FMIN) = 33+ fromEnum (OP_ADD) = 1+ fromEnum (OP_SINH) = 36+ fromEnum (OP_SUB) = 2+ fromEnum (OP_SIGN) = 29+ fromEnum (OP_SQ) = 11+ fromEnum (OP_NORMF) = 67+ fromEnum (OP_ACOSH) = 40+ fromEnum (OP_EXP) = 6+ fromEnum (OP_INPUT) = 44+ fromEnum (OP_OUTPUT) = 45+ fromEnum (OP_VERTCAT) = 54+ fromEnum (OP_EQ) = 21+ fromEnum (OP_INNER_PROD) = 53+ fromEnum (OP_MATMUL) = 48+ fromEnum (OP_TRANSPOSE) = 50+ fromEnum (OP_ASIN) = 16+ fromEnum (OP_COPYSIGN) = 30+ fromEnum (OP_ATANH) = 41+ fromEnum (NUM_BUILT_IN_OPS) = 71+ fromEnum (OP_ACOS) = 17+ fromEnum (OP_OR) = 25+ fromEnum (OP_TWICE) = 12+ fromEnum (OP_SUBREF) = 57+ fromEnum (OP_ATAN2) = 42+ fromEnum (OP_SET_SPARSE) = 62+ fromEnum (OP_ADDNONZEROS) = 60+ toEnum (61) = OP_SETNONZEROS+ toEnum (26) = OP_FLOOR+ toEnum (15) = OP_TAN+ toEnum (66) = OP_NORMINF+ toEnum (68) = OP_ERFINV+ toEnum (28) = OP_FABS+ toEnum (19) = OP_LT+ toEnum (70) = OP_LIFT+ toEnum (51) = OP_DETERMINANT+ toEnum (13) = OP_SIN+ toEnum (46) = OP_PARAMETER+ toEnum (38) = OP_TANH+ toEnum (3) = OP_MUL+ toEnum (23) = OP_NOT+ toEnum (31) = OP_IF_ELSE_ZERO+ toEnum (69) = OP_PRINTME+ toEnum (32) = OP_ERF+ toEnum (20) = OP_LE+ toEnum (47) = OP_CALL+ toEnum (49) = OP_SOLVE+ toEnum (22) = OP_NE+ toEnum (65) = OP_NORM1+ toEnum (9) = OP_CONSTPOW+ toEnum (4) = OP_DIV+ toEnum (56) = OP_RESHAPE+ toEnum (35) = OP_INV+ toEnum (64) = OP_NORM2+ toEnum (24) = OP_AND+ toEnum (14) = OP_COS+ toEnum (59) = OP_GETNONZEROS+ toEnum (34) = OP_FMAX+ toEnum (27) = OP_CEIL+ toEnum (8) = OP_POW+ toEnum (52) = OP_INVERSE+ toEnum (43) = OP_CONST+ toEnum (7) = OP_LOG+ toEnum (5) = OP_NEG+ toEnum (58) = OP_SUBASSIGN+ toEnum (18) = OP_ATAN+ toEnum (10) = OP_SQRT+ toEnum (63) = OP_ASSERTION+ toEnum (55) = OP_VERTSPLIT+ toEnum (39) = OP_ASINH+ toEnum (37) = OP_COSH+ toEnum (0) = OP_ASSIGN+ toEnum (33) = OP_FMIN+ toEnum (1) = OP_ADD+ toEnum (36) = OP_SINH+ toEnum (2) = OP_SUB+ toEnum (29) = OP_SIGN+ toEnum (11) = OP_SQ+ toEnum (67) = OP_NORMF+ toEnum (40) = OP_ACOSH+ toEnum (6) = OP_EXP+ toEnum (44) = OP_INPUT+ toEnum (45) = OP_OUTPUT+ toEnum (54) = OP_VERTCAT+ toEnum (21) = OP_EQ+ toEnum (53) = OP_INNER_PROD+ toEnum (48) = OP_MATMUL+ toEnum (50) = OP_TRANSPOSE+ toEnum (16) = OP_ASIN+ toEnum (30) = OP_COPYSIGN+ toEnum (41) = OP_ATANH+ toEnum (71) = NUM_BUILT_IN_OPS+ toEnum (17) = OP_ACOS+ toEnum (25) = OP_OR+ toEnum (12) = OP_TWICE+ toEnum (57) = OP_SUBREF+ toEnum (42) = OP_ATAN2+ toEnum (62) = OP_SET_SPARSE+ toEnum (60) = OP_ADDNONZEROS+ toEnum k+ = error $ "Operation: toEnum: got unhandled number: " ++ show k+instance Marshal Operation CInt where+ withMarshal x f = f (fromIntegral (fromEnum x))+instance WrapReturn CInt Operation where+ wrapReturn = return . toEnum . fromIntegral++-- EnumDecl: QPSolverOutput+data QPSolverOutput = QP_SOLVER_LAM_X+ | QP_SOLVER_COST+ | QP_SOLVER_LAM_A+ | QP_SOLVER_X+ | QP_SOLVER_NUM_OUT+ deriving (Show, Eq)+instance Enum QPSolverOutput where+ fromEnum (QP_SOLVER_LAM_X) = 3+ fromEnum (QP_SOLVER_COST) = 1+ fromEnum (QP_SOLVER_LAM_A) = 2+ fromEnum (QP_SOLVER_X) = 0+ fromEnum (QP_SOLVER_NUM_OUT) = 4+ toEnum (3) = QP_SOLVER_LAM_X+ toEnum (1) = QP_SOLVER_COST+ toEnum (2) = QP_SOLVER_LAM_A+ toEnum (0) = QP_SOLVER_X+ toEnum (4) = QP_SOLVER_NUM_OUT+ toEnum k+ = error $ "QPSolverOutput: toEnum: got unhandled number: " +++ show k+instance Marshal QPSolverOutput CInt where+ withMarshal x f = f (fromIntegral (fromEnum x))+instance WrapReturn CInt QPSolverOutput where+ wrapReturn = return . toEnum . fromIntegral+
+ Casadi/Wrappers/ForeignToolsImports.hs view
@@ -0,0 +1,49 @@+{-# OPTIONS_GHC -Wall #-}+{-# Language ForeignFunctionInterface #-}++module Casadi.Wrappers.ForeignToolsImports where++import Foreign.C.Types+import Foreign.Ptr ( Ptr )++import Casadi.MarshalTypes++--------------------------- ("int","CInt",Nothing,["Int"]) -----------------------------------+foreign import ccall unsafe "hs_new_vec_int" c_newVecCInt+ :: Ptr CInt -> CInt -> IO (Ptr (CppVec CInt))+foreign import ccall unsafe "hs_delete_vec_int" c_deleteVecCInt+ :: Ptr (CppVec CInt) -> IO ()+foreign import ccall unsafe "hs_new_vec_vec_int" c_newVecVecCInt+ :: Ptr CInt -> CInt -> Ptr CInt -> IO (Ptr (CppVecVec CInt))+foreign import ccall unsafe "hs_delete_vec_vec_int" c_deleteVecVecCInt+ :: Ptr (CppVecVec CInt) -> IO ()++--------------------------- ("voidp","VoidP",Just "(Ptr a)",[]) -----------------------------------+foreign import ccall unsafe "hs_new_vec_voidp" c_newVecVoidP+ :: Ptr (Ptr a) -> CInt -> IO (Ptr (CppVec (Ptr a)))+foreign import ccall unsafe "hs_delete_vec_voidp" c_deleteVecVoidP+ :: Ptr (CppVec (Ptr a)) -> IO ()+foreign import ccall unsafe "hs_new_vec_vec_voidp" c_newVecVecVoidP+ :: Ptr (Ptr a) -> CInt -> Ptr CInt -> IO (Ptr (CppVecVec (Ptr a)))+foreign import ccall unsafe "hs_delete_vec_vec_voidp" c_deleteVecVecVoidP+ :: Ptr (CppVecVec (Ptr a)) -> IO ()++--------------------------- ("uchar","CUChar",Nothing,[]) -----------------------------------+foreign import ccall unsafe "hs_new_vec_uchar" c_newVecCUChar+ :: Ptr CUChar -> CInt -> IO (Ptr (CppVec CUChar))+foreign import ccall unsafe "hs_delete_vec_uchar" c_deleteVecCUChar+ :: Ptr (CppVec CUChar) -> IO ()+foreign import ccall unsafe "hs_new_vec_vec_uchar" c_newVecVecCUChar+ :: Ptr CUChar -> CInt -> Ptr CInt -> IO (Ptr (CppVecVec CUChar))+foreign import ccall unsafe "hs_delete_vec_vec_uchar" c_deleteVecVecCUChar+ :: Ptr (CppVecVec CUChar) -> IO ()++--------------------------- ("double","CDouble",Nothing,["Double"]) -----------------------------------+foreign import ccall unsafe "hs_new_vec_double" c_newVecCDouble+ :: Ptr CDouble -> CInt -> IO (Ptr (CppVec CDouble))+foreign import ccall unsafe "hs_delete_vec_double" c_deleteVecCDouble+ :: Ptr (CppVec CDouble) -> IO ()+foreign import ccall unsafe "hs_new_vec_vec_double" c_newVecVecCDouble+ :: Ptr CDouble -> CInt -> Ptr CInt -> IO (Ptr (CppVecVec CDouble))+foreign import ccall unsafe "hs_delete_vec_vec_double" c_deleteVecVecCDouble+ :: Ptr (CppVecVec CDouble) -> IO ()
+ Casadi/Wrappers/ForeignToolsInstances.hs view
@@ -0,0 +1,30 @@+{-# OPTIONS_GHC -Wall -fno-warn-orphans #-}+{-# Language FlexibleInstances #-}+{-# Language MultiParamTypeClasses #-}++module Casadi.Wrappers.ForeignToolsInstances where++import Foreign.C.Types+import Foreign.Ptr ( Ptr )+import qualified Data.Vector as V++import Casadi.MarshalTypes+import Casadi.Marshal+import Casadi.Wrappers.ForeignToolsImports++instance Marshal (V.Vector CInt) (Ptr (CppVec CInt)) where+ withMarshal = withMarshalStorableVec c_newVecCInt c_deleteVecCInt+instance Marshal (V.Vector Int) (Ptr (CppVec CInt)) where+ withMarshal x = withMarshalStorableVec c_newVecCInt c_deleteVecCInt (V.map hsToC x)+instance Marshal (V.Vector (V.Vector Int)) (Ptr (CppVecVec CInt)) where+ withMarshal x = withMarshalStorableVecVec c_newVecVecCInt c_deleteVecVecCInt (V.map (V.map hsToC) x)+instance Marshal (V.Vector (Ptr a)) (Ptr (CppVec (Ptr a))) where+ withMarshal = withMarshalStorableVec c_newVecVoidP c_deleteVecVoidP+instance Marshal (V.Vector CUChar) (Ptr (CppVec CUChar)) where+ withMarshal = withMarshalStorableVec c_newVecCUChar c_deleteVecCUChar+instance Marshal (V.Vector CDouble) (Ptr (CppVec CDouble)) where+ withMarshal = withMarshalStorableVec c_newVecCDouble c_deleteVecCDouble+instance Marshal (V.Vector Double) (Ptr (CppVec CDouble)) where+ withMarshal x = withMarshalStorableVec c_newVecCDouble c_deleteVecCDouble (V.map hsToC x)+instance Marshal (V.Vector (V.Vector Double)) (Ptr (CppVecVec CDouble)) where+ withMarshal x = withMarshalStorableVecVec c_newVecVecCDouble c_deleteVecVecCDouble (V.map (V.map hsToC) x)
+ Casadi/Wrappers/Tools.hs view
@@ -0,0 +1,4841 @@+{-# OPTIONS_GHC -Wall #-}++module Casadi.Wrappers.Tools+ (+ addMultiple'',+ addMultiple''',+ addMultiple'''',+ addMultiple''''',+ adj',+ adj'',+ blkdiag',+ blkdiag'',+ blkdiag''',+ blkdiag'''',+ blockcat',+ blockcat'',+ blockcat''',+ blocksplit'''',+ blocksplit''''',+ blocksplit'''''',+ blocksplit''''''',+ blocksplit'''''''',+ blocksplit''''''''',+ blocksplit'''''''''',+ blocksplit''''''''''',+ blocksplit'''''''''''',+ blocksplit''''''''''''',+ blocksplit'''''''''''''',+ blocksplit''''''''''''''',+ cofactor',+ cofactor'',+ collocationInterpolators,+ collocationPoints,+ collocationPoints',+ complement,+ compress,+ compress',+ countNodes,+ countNodes',+ createParent,+ densify',+ densify'',+ densify''',+ dependsOn,+ det',+ det'',+ det''',+ diag',+ diag'',+ diag''',+ eig_symbolic,+ evalf,+ evalf',+ expand,+ explicitRK,+ explicitRK',+ explicitRK'',+ explicitRK''',+ extractShared,+ extractShared',+ extractShared'',+ extractShared''',+ extractShared'''',+ extractShared''''',+ fill,+ flatten',+ flatten'',+ flatten''',+ flattenNZ',+ flattenNZ'',+ flattenNZ''',+ flattenNZcat',+ flattenNZcat'',+ flattenNZcat''',+ flattencat',+ flattencat'',+ flattencat''',+ full',+ full'',+ full''',+ gauss_quadrature,+ gauss_quadrature',+ gauss_quadrature'',+ getFree,+ getIntValue,+ getIntValue',+ getIntValue'',+ getMinor',+ getMinor'',+ getNZDense,+ getOperatorRepresentation,+ getOperatorRepresentation',+ getSchemeEntryDoc,+ getSchemeEntryEnum,+ getSchemeEntryEnumName,+ getSchemeEntryName,+ getSchemeEntryNames,+ getSchemeName,+ getSchemeSize,+ getSparseTriplet',+ getSparseTriplet'',+ getSymbols,+ getSymbols',+ getSymbols'',+ getValue,+ getValue',+ getValue'',+ gradient,+ gradient',+ graph_substitute,+ graph_substitute',+ hasNonStructuralZeros',+ hasNonStructuralZeros'',+ hash_combine,+ hash_sparsity,+ heaviside,+ hessian,+ hessian',+ horzcat',+ horzcat'',+ horzcat''',+ horzcat'''',+ horzsplit''',+ horzsplit'''',+ horzsplit''''',+ horzsplit'''''',+ horzsplit''''''',+ horzsplit'''''''',+ horzsplit''''''''',+ horzsplit'''''''''',+ horzsplit''''''''''',+ if_else,+ if_else',+ inner_prod',+ inner_prod'',+ inner_prod''',+ inv',+ inv'',+ inv''',+ isConstant',+ isConstant'',+ isDecreasing,+ isDecreasing',+ isDense',+ isDense'',+ isDense''',+ isEmpty',+ isEmpty'',+ isEqual',+ isEqual'',+ isEqual''',+ isIdentity',+ isIdentity'',+ isIdentity''',+ isIncreasing,+ isIncreasing',+ isInteger',+ isInteger'',+ isMinusOne',+ isMinusOne'',+ isMinusOne''',+ isMonotone,+ isMonotone',+ isNonDecreasing,+ isNonDecreasing',+ isNonIncreasing,+ isNonIncreasing',+ isOne',+ isOne'',+ isOne''',+ isRegular,+ isRegular',+ isRegular''',+ isRegular'''',+ isRegular''''',+ isRegular'''''',+ isScalar',+ isScalar'',+ isSingular,+ isSmooth,+ isStrictlyMonotone,+ isStrictlyMonotone',+ isSymbolic,+ isSymbolic',+ isSymbolicSparse,+ isSymbolicSparse',+ isTranspose,+ isTril',+ isTril'',+ isTriu',+ isTriu'',+ isVector',+ isVector'',+ isVector''',+ isZero',+ isZero'',+ isZero''',+ jacobian,+ jacobian',+ jacobianTimesVector,+ jacobianTimesVector',+ kron',+ kron'',+ kron''',+ logic_and,+ logic_and',+ logic_and''',+ logic_and'''',+ logic_and''''',+ logic_and'''''',+ logic_not,+ logic_not',+ logic_not''',+ logic_not'''',+ logic_not''''',+ logic_not'''''',+ logic_or,+ logic_or',+ logic_or''',+ logic_or'''',+ logic_or''''',+ logic_or'''''',+ lookupvector,+ lowerNZ,+ lowerSparsity,+ lowerSparsity',+ makeDense',+ makeDense'',+ makeDense''',+ makeSparse'',+ makeSparse''',+ makeSparse'''',+ makeSparse''''',+ matrix_expand,+ matrix_expand',+ matrix_expand'',+ matrix_expand''',+ msym,+ msym',+ msym'',+ msym''',+ msym'''',+ msym''''',+ msym'''''',+ msym''''''',+ msym'''''''',+ mtaylor,+ mtaylor',+ mtaylor'',+ mul''',+ mul'''',+ mul''''',+ mul'''''',+ mul''''''',+ mul'''''''',+ mul''''''''',+ mul'''''''''',+ mul''''''''''',+ mul'''''''''''',+ nnz',+ nnz'',+ nnz_sym',+ nnz_sym'',+ norm_1',+ norm_1'',+ norm_1''',+ norm_2',+ norm_2'',+ norm_2''',+ norm_F',+ norm_F'',+ norm_F''',+ norm_inf',+ norm_inf'',+ norm_inf''',+ nullspace',+ nullspace'',+ nullspace''',+ numSample1D,+ numSample1DT,+ numSample2D,+ outer_prod',+ outer_prod'',+ outer_prod''',+ parameterizeTime,+ parameterizeTimeOutput,+ pinv',+ pinv'',+ poly_coeff,+ poly_roots,+ polyval',+ polyval'',+ polyval''',+ printCompact',+ printCompact''',+ project',+ project'',+ pw_const,+ pw_lin,+ qr',+ qr'',+ ramp,+ rank,+ rectangle,+ repmat',+ repmat'',+ repmat''',+ reshape'',+ reshape''',+ reshape'''',+ reshape''''',+ reshape'''''',+ reshape''''''',+ simplify,+ simplify',+ simplify'',+ solve',+ solve'',+ sp_band,+ sp_banded,+ sp_compress,+ sp_compress',+ sp_dense,+ sp_dense',+ sp_diag,+ sp_rowcol,+ sp_sparse,+ sp_sparse',+ sp_tril,+ sp_triplet,+ sp_triplet',+ sp_triplet'',+ sp_unit,+ sparse'',+ sparse''',+ sparse'''',+ sparse''''',+ sprank',+ sprank'',+ spy,+ ssym,+ ssym',+ ssym'',+ ssym''',+ ssym'''',+ ssym''''',+ ssym'''''',+ ssym''''''',+ ssym'''''''',+ substitute,+ substitute',+ substitute'',+ substitute''',+ substituteInPlace,+ substituteInPlace',+ substituteInPlace'',+ substituteInPlace''',+ substituteInPlace'''',+ substituteInPlace''''',+ substituteInPlace'''''',+ substituteInPlace''''''',+ substituteInPlace'''''''',+ substituteInPlace''''''''',+ sumAll',+ sumAll'',+ sumAll''',+ sumCols',+ sumCols'',+ sumCols''',+ sumRows',+ sumRows'',+ sumRows''',+ tangent,+ tangent',+ taylor,+ taylor',+ taylor'',+ trace',+ trace'',+ trace''',+ trans',+ trans'',+ trans''',+ trans'''',+ triangle,+ unite',+ unite'',+ unite''',+ vec',+ vec'',+ vec''',+ vec'''',+ vec''''',+ vec'''''',+ vecNZ',+ vecNZ'',+ vecNZ''',+ vecNZcat',+ vecNZcat'',+ vecNZcat''',+ veccat',+ veccat'',+ veccat''',+ vertcat',+ vertcat'',+ vertcat''',+ vertcat'''',+ vertsplit''',+ vertsplit'''',+ vertsplit''''',+ vertsplit'''''',+ vertsplit''''''',+ vertsplit'''''''',+ vertsplit''''''''',+ vertsplit'''''''''',+ vertsplit''''''''''',+ ) where+++import Data.Vector ( Vector )+import Foreign.C.Types+import Foreign.Ptr ( Ptr )+import Foreign.ForeignPtr ( newForeignPtr )++import Casadi.Wrappers.Data+import Casadi.Wrappers.Enums+import Casadi.Wrappers.Deleters+import Casadi.Wrappers.ForeignToolsInstances ( )+import Casadi.MarshalTypes ( CppVec, CppVecVec, CppBool', StdString' )+import Casadi.Marshal ( CornerCase(..), Marshal(..) )+import Casadi.WrapReturn ( WrapReturn(..) )++foreign import ccall unsafe "CasADi__getSchemeEntryName" c_CasADi__getSchemeEntryName+ :: CInt -> CInt -> IO (Ptr StdString')+getSchemeEntryName+ :: InputOutputScheme -> Int -> IO String+getSchemeEntryName x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__getSchemeEntryName x0' x1' >>= (newForeignPtr c_delete_std__string) >>= wrapReturn++foreign import ccall unsafe "CasADi__getSchemeEntryDoc" c_CasADi__getSchemeEntryDoc+ :: CInt -> CInt -> IO (Ptr StdString')+getSchemeEntryDoc+ :: InputOutputScheme -> Int -> IO String+getSchemeEntryDoc x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__getSchemeEntryDoc x0' x1' >>= (newForeignPtr c_delete_std__string) >>= wrapReturn++foreign import ccall unsafe "CasADi__getSchemeEntryEnumName" c_CasADi__getSchemeEntryEnumName+ :: CInt -> CInt -> IO (Ptr StdString')+getSchemeEntryEnumName+ :: InputOutputScheme -> Int -> IO String+getSchemeEntryEnumName x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__getSchemeEntryEnumName x0' x1' >>= (newForeignPtr c_delete_std__string) >>= wrapReturn++foreign import ccall unsafe "CasADi__getSchemeEntryEnum" c_CasADi__getSchemeEntryEnum+ :: CInt -> Ptr StdString' -> IO CInt+getSchemeEntryEnum+ :: InputOutputScheme -> String -> IO Int+getSchemeEntryEnum x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__getSchemeEntryEnum x0' x1' >>= wrapReturn++foreign import ccall unsafe "CasADi__getSchemeSize" c_CasADi__getSchemeSize+ :: CInt -> IO CInt+getSchemeSize+ :: InputOutputScheme -> IO Int+getSchemeSize x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__getSchemeSize x0' >>= wrapReturn++foreign import ccall unsafe "CasADi__getSchemeName" c_CasADi__getSchemeName+ :: CInt -> IO (Ptr StdString')+getSchemeName+ :: InputOutputScheme -> IO String+getSchemeName x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__getSchemeName x0' >>= (newForeignPtr c_delete_std__string) >>= wrapReturn++foreign import ccall unsafe "CasADi__getSchemeEntryNames" c_CasADi__getSchemeEntryNames+ :: CInt -> IO (Ptr StdString')+getSchemeEntryNames+ :: InputOutputScheme -> IO String+getSchemeEntryNames x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__getSchemeEntryNames x0' >>= (newForeignPtr c_delete_std__string) >>= wrapReturn++foreign import ccall unsafe "CasADi__complement" c_CasADi__complement+ :: Ptr (CppVec CInt) -> CInt -> IO (Ptr (CppVec CInt))+{-|+>Returns the list of all i in [0,size[ not found in supplied list.+>+>The supplied vector may contain duplicates and may be non-monotonous The+>supplied vector will be checked for bounds The result vector is guaranteed+>to be monotonously increasing+-}+complement+ :: Vector Int -> Int -> IO (Vector Int)+complement x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__complement x0' x1' >>= (newForeignPtr c_delete_std__vector_int_) >>= wrapReturn++foreign import ccall unsafe "CasADi__lookupvector" c_CasADi__lookupvector+ :: Ptr (CppVec CInt) -> CInt -> IO (Ptr (CppVec CInt))+{-|+>Returns a vector for quickly looking up entries of supplied list.+>+>lookupvector[i]!=-1 <=> v contains i v[lookupvector[i]] == i <=> v contains+>i+>+>Duplicates are treated by looking up last occurence+-}+lookupvector+ :: Vector Int -> Int -> IO (Vector Int)+lookupvector x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__lookupvector x0' x1' >>= (newForeignPtr c_delete_std__vector_int_) >>= wrapReturn++foreign import ccall unsafe "CasADi__isIncreasing" c_CasADi__isIncreasing+ :: Ptr (CppVec CInt) -> IO (Ptr CppBool')+{-|+>Check if the vector is strictly increasing.+-}+isIncreasing+ :: Vector Int -> IO Bool+isIncreasing x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__isIncreasing x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++foreign import ccall unsafe "CasADi__isDecreasing" c_CasADi__isDecreasing+ :: Ptr (CppVec CInt) -> IO (Ptr CppBool')+{-|+>Check if the vector is strictly decreasing.+-}+isDecreasing+ :: Vector Int -> IO Bool+isDecreasing x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__isDecreasing x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++foreign import ccall unsafe "CasADi__isNonIncreasing" c_CasADi__isNonIncreasing+ :: Ptr (CppVec CInt) -> IO (Ptr CppBool')+{-|+>Check if the vector is non-increasing.+-}+isNonIncreasing+ :: Vector Int -> IO Bool+isNonIncreasing x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__isNonIncreasing x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++foreign import ccall unsafe "CasADi__isNonDecreasing" c_CasADi__isNonDecreasing+ :: Ptr (CppVec CInt) -> IO (Ptr CppBool')+{-|+>Check if the vector is non-decreasing.+-}+isNonDecreasing+ :: Vector Int -> IO Bool+isNonDecreasing x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__isNonDecreasing x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++foreign import ccall unsafe "CasADi__isMonotone" c_CasADi__isMonotone+ :: Ptr (CppVec CInt) -> IO (Ptr CppBool')+{-|+>Check if the vector is monotone.+-}+isMonotone+ :: Vector Int -> IO Bool+isMonotone x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__isMonotone x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++foreign import ccall unsafe "CasADi__isStrictlyMonotone" c_CasADi__isStrictlyMonotone+ :: Ptr (CppVec CInt) -> IO (Ptr CppBool')+{-|+>Check if the vector is strictly monotone.+-}+isStrictlyMonotone+ :: Vector Int -> IO Bool+isStrictlyMonotone x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__isStrictlyMonotone x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++foreign import ccall unsafe "CasADi__isRegular" c_CasADi__isRegular+ :: Ptr (CppVec CInt) -> IO (Ptr CppBool')+{-|+>> bool CasADi::isRegular(const Matrix< int > &ex)+>+>> bool CasADi::isRegular(const std::vector< T > &vec)+>------------------------------------------------------------------------+>+>Checks if vector does not contain NaN or Inf.+>+>> bool CasADi::isRegular(const MX &ex)+>------------------------------------------------------------------------+>+>Checks if expression does not contain NaN or Inf.+>+>> bool CasADi::isRegular(const SX &ex)+>------------------------------------------------------------------------+>+>Make the expression smooth by replacing non-smooth nodes with binary+>variables.+>+>Substitute derivatives with variables void replaceDerivatives(SXMatrix &ex,+>const SXMatrix &var, const SXMatrix &dvar); Checks if expression does not+>contain NaN or Inf+-}+isRegular+ :: Vector Int -> IO Bool+isRegular x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__isRegular x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++foreign import ccall unsafe "CasADi__isIncreasing_TIC" c_CasADi__isIncreasing_TIC+ :: Ptr (CppVec CDouble) -> IO (Ptr CppBool')+isIncreasing'+ :: Vector Double -> IO Bool+isIncreasing' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__isIncreasing_TIC x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++foreign import ccall unsafe "CasADi__isDecreasing_TIC" c_CasADi__isDecreasing_TIC+ :: Ptr (CppVec CDouble) -> IO (Ptr CppBool')+isDecreasing'+ :: Vector Double -> IO Bool+isDecreasing' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__isDecreasing_TIC x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++foreign import ccall unsafe "CasADi__isNonIncreasing_TIC" c_CasADi__isNonIncreasing_TIC+ :: Ptr (CppVec CDouble) -> IO (Ptr CppBool')+isNonIncreasing'+ :: Vector Double -> IO Bool+isNonIncreasing' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__isNonIncreasing_TIC x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++foreign import ccall unsafe "CasADi__isNonDecreasing_TIC" c_CasADi__isNonDecreasing_TIC+ :: Ptr (CppVec CDouble) -> IO (Ptr CppBool')+isNonDecreasing'+ :: Vector Double -> IO Bool+isNonDecreasing' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__isNonDecreasing_TIC x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++foreign import ccall unsafe "CasADi__isMonotone_TIC" c_CasADi__isMonotone_TIC+ :: Ptr (CppVec CDouble) -> IO (Ptr CppBool')+isMonotone'+ :: Vector Double -> IO Bool+isMonotone' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__isMonotone_TIC x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++foreign import ccall unsafe "CasADi__isStrictlyMonotone_TIC" c_CasADi__isStrictlyMonotone_TIC+ :: Ptr (CppVec CDouble) -> IO (Ptr CppBool')+isStrictlyMonotone'+ :: Vector Double -> IO Bool+isStrictlyMonotone' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__isStrictlyMonotone_TIC x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++foreign import ccall unsafe "CasADi__isRegular_TIC" c_CasADi__isRegular_TIC+ :: Ptr (CppVec CDouble) -> IO (Ptr CppBool')+isRegular'+ :: Vector Double -> IO Bool+isRegular' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__isRegular_TIC x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++foreign import ccall unsafe "CasADi__isRegular_TIC_TIC_TIC" c_CasADi__isRegular_TIC_TIC_TIC+ :: Ptr DMatrix' -> IO (Ptr CppBool')+isRegular'''+ :: DMatrix -> IO Bool+isRegular''' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__isRegular_TIC_TIC_TIC x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++foreign import ccall unsafe "CasADi__trans_TIC" c_CasADi__trans_TIC+ :: Ptr DMatrix' -> IO (Ptr DMatrix')+trans'+ :: DMatrix -> IO DMatrix+trans' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__trans_TIC x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++foreign import ccall unsafe "CasADi__mul_TIC_TIC_TIC" c_CasADi__mul_TIC_TIC_TIC+ :: Ptr DMatrix' -> Ptr DMatrix' -> Ptr CRSSparsity' -> IO (Ptr DMatrix')+mul'''+ :: DMatrix -> DMatrix -> CRSSparsity -> IO DMatrix+mul''' x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__mul_TIC_TIC_TIC x0' x1' x2' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++foreign import ccall unsafe "CasADi__mul_TIC_TIC_TIC_TIC" c_CasADi__mul_TIC_TIC_TIC_TIC+ :: Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')+mul''''+ :: DMatrix -> DMatrix -> IO DMatrix+mul'''' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__mul_TIC_TIC_TIC_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++foreign import ccall unsafe "CasADi__mul_TIC_TIC_TIC_TIC_TIC" c_CasADi__mul_TIC_TIC_TIC_TIC_TIC+ :: Ptr (CppVec (Ptr DMatrix')) -> IO (Ptr DMatrix')+mul'''''+ :: Vector DMatrix -> IO DMatrix+mul''''' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__mul_TIC_TIC_TIC_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++foreign import ccall unsafe "CasADi__isConstant_TIC" c_CasADi__isConstant_TIC+ :: Ptr DMatrix' -> IO (Ptr CppBool')+isConstant'+ :: DMatrix -> IO Bool+isConstant' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__isConstant_TIC x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++foreign import ccall unsafe "CasADi__isDense_TIC" c_CasADi__isDense_TIC+ :: Ptr DMatrix' -> IO (Ptr CppBool')+isDense'+ :: DMatrix -> IO Bool+isDense' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__isDense_TIC x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++foreign import ccall unsafe "CasADi__isEmpty_TIC" c_CasADi__isEmpty_TIC+ :: Ptr DMatrix' -> IO (Ptr CppBool')+isEmpty'+ :: DMatrix -> IO Bool+isEmpty' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__isEmpty_TIC x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++foreign import ccall unsafe "CasADi__isInteger_TIC" c_CasADi__isInteger_TIC+ :: Ptr DMatrix' -> IO (Ptr CppBool')+isInteger'+ :: DMatrix -> IO Bool+isInteger' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__isInteger_TIC x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++foreign import ccall unsafe "CasADi__isScalar_TIC" c_CasADi__isScalar_TIC+ :: Ptr DMatrix' -> IO (Ptr CppBool')+isScalar'+ :: DMatrix -> IO Bool+isScalar' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__isScalar_TIC x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++foreign import ccall unsafe "CasADi__isVector_TIC" c_CasADi__isVector_TIC+ :: Ptr DMatrix' -> IO (Ptr CppBool')+isVector'+ :: DMatrix -> IO Bool+isVector' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__isVector_TIC x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++foreign import ccall unsafe "CasADi__isTril_TIC" c_CasADi__isTril_TIC+ :: Ptr DMatrix' -> IO (Ptr CppBool')+isTril'+ :: DMatrix -> IO Bool+isTril' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__isTril_TIC x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++foreign import ccall unsafe "CasADi__isTriu_TIC" c_CasADi__isTriu_TIC+ :: Ptr DMatrix' -> IO (Ptr CppBool')+isTriu'+ :: DMatrix -> IO Bool+isTriu' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__isTriu_TIC x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++foreign import ccall unsafe "CasADi__det_TIC" c_CasADi__det_TIC+ :: Ptr DMatrix' -> IO CDouble+det'+ :: DMatrix -> IO Double+det' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__det_TIC x0' >>= wrapReturn++foreign import ccall unsafe "CasADi__getMinor_TIC" c_CasADi__getMinor_TIC+ :: Ptr DMatrix' -> CInt -> CInt -> IO CDouble+getMinor'+ :: DMatrix -> Int -> Int -> IO Double+getMinor' x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__getMinor_TIC x0' x1' x2' >>= wrapReturn++foreign import ccall unsafe "CasADi__cofactor_TIC" c_CasADi__cofactor_TIC+ :: Ptr DMatrix' -> CInt -> CInt -> IO CDouble+cofactor'+ :: DMatrix -> Int -> Int -> IO Double+cofactor' x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__cofactor_TIC x0' x1' x2' >>= wrapReturn++foreign import ccall unsafe "CasADi__adj_TIC" c_CasADi__adj_TIC+ :: Ptr DMatrix' -> IO (Ptr DMatrix')+adj'+ :: DMatrix -> IO DMatrix+adj' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__adj_TIC x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++foreign import ccall unsafe "CasADi__inv_TIC" c_CasADi__inv_TIC+ :: Ptr DMatrix' -> IO (Ptr DMatrix')+inv'+ :: DMatrix -> IO DMatrix+inv' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__inv_TIC x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++foreign import ccall unsafe "CasADi__reshape_TIC_TIC" c_CasADi__reshape_TIC_TIC+ :: Ptr DMatrix' -> CInt -> CInt -> IO (Ptr DMatrix')+reshape''+ :: DMatrix -> Int -> Int -> IO DMatrix+reshape'' x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__reshape_TIC_TIC x0' x1' x2' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++foreign import ccall unsafe "CasADi__reshape_TIC_TIC_TIC" c_CasADi__reshape_TIC_TIC_TIC+ :: Ptr DMatrix' -> Ptr CRSSparsity' -> IO (Ptr DMatrix')+reshape'''+ :: DMatrix -> CRSSparsity -> IO DMatrix+reshape''' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__reshape_TIC_TIC_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++foreign import ccall unsafe "CasADi__vec_TIC" c_CasADi__vec_TIC+ :: Ptr DMatrix' -> IO (Ptr DMatrix')+vec'+ :: DMatrix -> IO DMatrix+vec' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__vec_TIC x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++foreign import ccall unsafe "CasADi__flatten_TIC" c_CasADi__flatten_TIC+ :: Ptr DMatrix' -> IO (Ptr DMatrix')+flatten'+ :: DMatrix -> IO DMatrix+flatten' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__flatten_TIC x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++foreign import ccall unsafe "CasADi__vecNZ_TIC" c_CasADi__vecNZ_TIC+ :: Ptr DMatrix' -> IO (Ptr DMatrix')+vecNZ'+ :: DMatrix -> IO DMatrix+vecNZ' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__vecNZ_TIC x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++foreign import ccall unsafe "CasADi__flattenNZ_TIC" c_CasADi__flattenNZ_TIC+ :: Ptr DMatrix' -> IO (Ptr DMatrix')+flattenNZ'+ :: DMatrix -> IO DMatrix+flattenNZ' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__flattenNZ_TIC x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++foreign import ccall unsafe "CasADi__blockcat_TIC" c_CasADi__blockcat_TIC+ :: Ptr (CppVecVec (Ptr DMatrix')) -> IO (Ptr DMatrix')+blockcat'+ :: Vector (Vector DMatrix) -> IO DMatrix+blockcat' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__blockcat_TIC x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++foreign import ccall unsafe "CasADi__blocksplit_TIC_TIC_TIC_TIC" c_CasADi__blocksplit_TIC_TIC_TIC_TIC+ :: Ptr DMatrix' -> Ptr (CppVec CInt) -> Ptr (CppVec CInt) -> IO (Ptr (CppVecVec (Ptr DMatrix')))+blocksplit''''+ :: DMatrix -> Vector Int -> Vector Int -> IO (Vector (Vector DMatrix))+blocksplit'''' x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__blocksplit_TIC_TIC_TIC_TIC x0' x1' x2' >>= (newForeignPtr c_delete_std__vector_std__vector_CasADi__Matrix_double___) >>= wrapReturn++foreign import ccall unsafe "CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC" c_CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC+ :: Ptr DMatrix' -> CInt -> CInt -> IO (Ptr (CppVecVec (Ptr DMatrix')))+blocksplit'''''+ :: DMatrix -> Int -> Int -> IO (Vector (Vector DMatrix))+blocksplit''''' x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC x0' x1' x2' >>= (newForeignPtr c_delete_std__vector_std__vector_CasADi__Matrix_double___) >>= wrapReturn++foreign import ccall unsafe "CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC+ :: Ptr DMatrix' -> CInt -> IO (Ptr (CppVecVec (Ptr DMatrix')))+blocksplit''''''+ :: DMatrix -> Int -> IO (Vector (Vector DMatrix))+blocksplit'''''' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' >>= (newForeignPtr c_delete_std__vector_std__vector_CasADi__Matrix_double___) >>= wrapReturn++foreign import ccall unsafe "CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC+ :: Ptr DMatrix' -> IO (Ptr (CppVecVec (Ptr DMatrix')))+blocksplit'''''''+ :: DMatrix -> IO (Vector (Vector DMatrix))+blocksplit''''''' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' >>= (newForeignPtr c_delete_std__vector_std__vector_CasADi__Matrix_double___) >>= wrapReturn++foreign import ccall unsafe "CasADi__horzcat_TIC" c_CasADi__horzcat_TIC+ :: Ptr (CppVec (Ptr DMatrix')) -> IO (Ptr DMatrix')+horzcat'+ :: Vector DMatrix -> IO DMatrix+horzcat' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__horzcat_TIC x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++foreign import ccall unsafe "CasADi__horzsplit_TIC_TIC_TIC" c_CasADi__horzsplit_TIC_TIC_TIC+ :: Ptr DMatrix' -> Ptr (CppVec CInt) -> IO (Ptr (CppVec (Ptr DMatrix')))+horzsplit'''+ :: DMatrix -> Vector Int -> IO (Vector DMatrix)+horzsplit''' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__horzsplit_TIC_TIC_TIC x0' x1' >>= (newForeignPtr c_delete_std__vector_CasADi__Matrix_double__) >>= wrapReturn++foreign import ccall unsafe "CasADi__horzsplit_TIC_TIC_TIC_TIC" c_CasADi__horzsplit_TIC_TIC_TIC_TIC+ :: Ptr DMatrix' -> CInt -> IO (Ptr (CppVec (Ptr DMatrix')))+horzsplit''''+ :: DMatrix -> Int -> IO (Vector DMatrix)+horzsplit'''' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__horzsplit_TIC_TIC_TIC_TIC x0' x1' >>= (newForeignPtr c_delete_std__vector_CasADi__Matrix_double__) >>= wrapReturn++foreign import ccall unsafe "CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC" c_CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC+ :: Ptr DMatrix' -> IO (Ptr (CppVec (Ptr DMatrix')))+horzsplit'''''+ :: DMatrix -> IO (Vector DMatrix)+horzsplit''''' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC x0' >>= (newForeignPtr c_delete_std__vector_CasADi__Matrix_double__) >>= wrapReturn++foreign import ccall unsafe "CasADi__vertcat_TIC" c_CasADi__vertcat_TIC+ :: Ptr (CppVec (Ptr DMatrix')) -> IO (Ptr DMatrix')+vertcat'+ :: Vector DMatrix -> IO DMatrix+vertcat' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__vertcat_TIC x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++foreign import ccall unsafe "CasADi__vertsplit_TIC_TIC_TIC" c_CasADi__vertsplit_TIC_TIC_TIC+ :: Ptr DMatrix' -> Ptr (CppVec CInt) -> IO (Ptr (CppVec (Ptr DMatrix')))+vertsplit'''+ :: DMatrix -> Vector Int -> IO (Vector DMatrix)+vertsplit''' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__vertsplit_TIC_TIC_TIC x0' x1' >>= (newForeignPtr c_delete_std__vector_CasADi__Matrix_double__) >>= wrapReturn++foreign import ccall unsafe "CasADi__vertsplit_TIC_TIC_TIC_TIC" c_CasADi__vertsplit_TIC_TIC_TIC_TIC+ :: Ptr DMatrix' -> CInt -> IO (Ptr (CppVec (Ptr DMatrix')))+vertsplit''''+ :: DMatrix -> Int -> IO (Vector DMatrix)+vertsplit'''' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__vertsplit_TIC_TIC_TIC_TIC x0' x1' >>= (newForeignPtr c_delete_std__vector_CasADi__Matrix_double__) >>= wrapReturn++foreign import ccall unsafe "CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC" c_CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC+ :: Ptr DMatrix' -> IO (Ptr (CppVec (Ptr DMatrix')))+vertsplit'''''+ :: DMatrix -> IO (Vector DMatrix)+vertsplit''''' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC x0' >>= (newForeignPtr c_delete_std__vector_CasADi__Matrix_double__) >>= wrapReturn++foreign import ccall unsafe "CasADi__inner_prod_TIC" c_CasADi__inner_prod_TIC+ :: Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')+inner_prod'+ :: DMatrix -> DMatrix -> IO DMatrix+inner_prod' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__inner_prod_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++foreign import ccall unsafe "CasADi__outer_prod_TIC" c_CasADi__outer_prod_TIC+ :: Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')+outer_prod'+ :: DMatrix -> DMatrix -> IO DMatrix+outer_prod' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__outer_prod_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++foreign import ccall unsafe "CasADi__norm_1_TIC" c_CasADi__norm_1_TIC+ :: Ptr DMatrix' -> IO (Ptr DMatrix')+norm_1'+ :: DMatrix -> IO DMatrix+norm_1' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__norm_1_TIC x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++foreign import ccall unsafe "CasADi__norm_2_TIC" c_CasADi__norm_2_TIC+ :: Ptr DMatrix' -> IO (Ptr DMatrix')+norm_2'+ :: DMatrix -> IO DMatrix+norm_2' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__norm_2_TIC x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++foreign import ccall unsafe "CasADi__norm_inf_TIC" c_CasADi__norm_inf_TIC+ :: Ptr DMatrix' -> IO (Ptr DMatrix')+norm_inf'+ :: DMatrix -> IO DMatrix+norm_inf' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__norm_inf_TIC x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++foreign import ccall unsafe "CasADi__norm_F_TIC" c_CasADi__norm_F_TIC+ :: Ptr DMatrix' -> IO (Ptr DMatrix')+norm_F'+ :: DMatrix -> IO DMatrix+norm_F' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__norm_F_TIC x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++foreign import ccall unsafe "CasADi__qr_TIC" c_CasADi__qr_TIC+ :: Ptr DMatrix' -> Ptr DMatrix' -> Ptr DMatrix' -> IO ()+qr'+ :: DMatrix -> DMatrix -> DMatrix -> IO ()+qr' x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__qr_TIC x0' x1' x2' >>= wrapReturn++foreign import ccall unsafe "CasADi__nullspace_TIC" c_CasADi__nullspace_TIC+ :: Ptr DMatrix' -> IO (Ptr DMatrix')+nullspace'+ :: DMatrix -> IO DMatrix+nullspace' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__nullspace_TIC x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++foreign import ccall unsafe "CasADi__solve_TIC" c_CasADi__solve_TIC+ :: Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')+solve'+ :: DMatrix -> DMatrix -> IO DMatrix+solve' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__solve_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++foreign import ccall unsafe "CasADi__pinv_TIC" c_CasADi__pinv_TIC+ :: Ptr DMatrix' -> IO (Ptr DMatrix')+pinv'+ :: DMatrix -> IO DMatrix+pinv' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__pinv_TIC x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++foreign import ccall unsafe "CasADi__isZero_TIC" c_CasADi__isZero_TIC+ :: Ptr DMatrix' -> IO (Ptr CppBool')+isZero'+ :: DMatrix -> IO Bool+isZero' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__isZero_TIC x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++foreign import ccall unsafe "CasADi__isOne_TIC" c_CasADi__isOne_TIC+ :: Ptr DMatrix' -> IO (Ptr CppBool')+isOne'+ :: DMatrix -> IO Bool+isOne' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__isOne_TIC x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++foreign import ccall unsafe "CasADi__isMinusOne_TIC" c_CasADi__isMinusOne_TIC+ :: Ptr DMatrix' -> IO (Ptr CppBool')+isMinusOne'+ :: DMatrix -> IO Bool+isMinusOne' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__isMinusOne_TIC x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++foreign import ccall unsafe "CasADi__isIdentity_TIC" c_CasADi__isIdentity_TIC+ :: Ptr DMatrix' -> IO (Ptr CppBool')+isIdentity'+ :: DMatrix -> IO Bool+isIdentity' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__isIdentity_TIC x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++foreign import ccall unsafe "CasADi__nnz_TIC" c_CasADi__nnz_TIC+ :: Ptr DMatrix' -> IO CInt+nnz'+ :: DMatrix -> IO Int+nnz' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__nnz_TIC x0' >>= wrapReturn++foreign import ccall unsafe "CasADi__nnz_sym_TIC" c_CasADi__nnz_sym_TIC+ :: Ptr DMatrix' -> IO CInt+nnz_sym'+ :: DMatrix -> IO Int+nnz_sym' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__nnz_sym_TIC x0' >>= wrapReturn++foreign import ccall unsafe "CasADi__isEqual_TIC" c_CasADi__isEqual_TIC+ :: Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr CppBool')+isEqual'+ :: DMatrix -> DMatrix -> IO Bool+isEqual' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__isEqual_TIC x0' x1' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++foreign import ccall unsafe "CasADi__repmat_TIC" c_CasADi__repmat_TIC+ :: Ptr DMatrix' -> CInt -> CInt -> IO (Ptr DMatrix')+repmat'+ :: DMatrix -> Int -> Int -> IO DMatrix+repmat' x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__repmat_TIC x0' x1' x2' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++foreign import ccall unsafe "CasADi__getSparseTriplet_TIC" c_CasADi__getSparseTriplet_TIC+ :: Ptr DMatrix' -> IO (Ptr (CppVecVec CInt))+getSparseTriplet'+ :: DMatrix -> IO (Vector (Vector Int))+getSparseTriplet' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__getSparseTriplet_TIC x0' >>= (newForeignPtr c_delete_std__vector_std__vector_int__) >>= wrapReturn++foreign import ccall unsafe "CasADi__unite_TIC" c_CasADi__unite_TIC+ :: Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')+unite'+ :: DMatrix -> DMatrix -> IO DMatrix+unite' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__unite_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++foreign import ccall unsafe "CasADi__sumCols_TIC" c_CasADi__sumCols_TIC+ :: Ptr DMatrix' -> IO (Ptr DMatrix')+sumCols'+ :: DMatrix -> IO DMatrix+sumCols' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__sumCols_TIC x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++foreign import ccall unsafe "CasADi__sumRows_TIC" c_CasADi__sumRows_TIC+ :: Ptr DMatrix' -> IO (Ptr DMatrix')+sumRows'+ :: DMatrix -> IO DMatrix+sumRows' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__sumRows_TIC x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++foreign import ccall unsafe "CasADi__sumAll_TIC" c_CasADi__sumAll_TIC+ :: Ptr DMatrix' -> IO (Ptr DMatrix')+sumAll'+ :: DMatrix -> IO DMatrix+sumAll' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__sumAll_TIC x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++foreign import ccall unsafe "CasADi__trace_TIC" c_CasADi__trace_TIC+ :: Ptr DMatrix' -> IO CDouble+trace'+ :: DMatrix -> IO Double+trace' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__trace_TIC x0' >>= wrapReturn++foreign import ccall unsafe "CasADi__makeDense_TIC" c_CasADi__makeDense_TIC+ :: Ptr DMatrix' -> IO ()+makeDense'+ :: DMatrix -> IO ()+makeDense' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__makeDense_TIC x0' >>= wrapReturn++foreign import ccall unsafe "CasADi__densify_TIC" c_CasADi__densify_TIC+ :: Ptr DMatrix' -> IO (Ptr DMatrix')+densify'+ :: DMatrix -> IO DMatrix+densify' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__densify_TIC x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++foreign import ccall unsafe "CasADi__makeSparse_TIC_TIC" c_CasADi__makeSparse_TIC_TIC+ :: Ptr DMatrix' -> CDouble -> IO ()+makeSparse''+ :: DMatrix -> Double -> IO ()+makeSparse'' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__makeSparse_TIC_TIC x0' x1' >>= wrapReturn++foreign import ccall unsafe "CasADi__makeSparse_TIC_TIC_TIC" c_CasADi__makeSparse_TIC_TIC_TIC+ :: Ptr DMatrix' -> IO ()+makeSparse'''+ :: DMatrix -> IO ()+makeSparse''' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__makeSparse_TIC_TIC_TIC x0' >>= wrapReturn++foreign import ccall unsafe "CasADi__hasNonStructuralZeros_TIC" c_CasADi__hasNonStructuralZeros_TIC+ :: Ptr DMatrix' -> IO (Ptr CppBool')+hasNonStructuralZeros'+ :: DMatrix -> IO Bool+hasNonStructuralZeros' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__hasNonStructuralZeros_TIC x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++foreign import ccall unsafe "CasADi__diag_TIC" c_CasADi__diag_TIC+ :: Ptr DMatrix' -> IO (Ptr DMatrix')+diag'+ :: DMatrix -> IO DMatrix+diag' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__diag_TIC x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++foreign import ccall unsafe "CasADi__blkdiag_TIC" c_CasADi__blkdiag_TIC+ :: Ptr (CppVec (Ptr DMatrix')) -> IO (Ptr DMatrix')+blkdiag'+ :: Vector DMatrix -> IO DMatrix+blkdiag' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__blkdiag_TIC x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++foreign import ccall unsafe "CasADi__polyval_TIC" c_CasADi__polyval_TIC+ :: Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')+polyval'+ :: DMatrix -> DMatrix -> IO DMatrix+polyval' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__polyval_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++foreign import ccall unsafe "CasADi__addMultiple_TIC_TIC" c_CasADi__addMultiple_TIC_TIC+ :: Ptr DMatrix' -> Ptr (CppVec CDouble) -> Ptr (CppVec CDouble) -> Ptr CppBool' -> IO ()+addMultiple''+ :: DMatrix -> Vector Double -> Vector Double -> Bool -> IO ()+addMultiple'' x0 x1 x2 x3 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ withMarshal x3 $ \x3' ->+ c_CasADi__addMultiple_TIC_TIC x0' x1' x2' x3' >>= wrapReturn++foreign import ccall unsafe "CasADi__addMultiple_TIC_TIC_TIC" c_CasADi__addMultiple_TIC_TIC_TIC+ :: Ptr DMatrix' -> Ptr (CppVec CDouble) -> Ptr (CppVec CDouble) -> IO ()+addMultiple'''+ :: DMatrix -> Vector Double -> Vector Double -> IO ()+addMultiple''' x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__addMultiple_TIC_TIC_TIC x0' x1' x2' >>= wrapReturn++foreign import ccall unsafe "CasADi__veccat_TIC" c_CasADi__veccat_TIC+ :: Ptr (CppVec (Ptr DMatrix')) -> IO (Ptr DMatrix')+veccat'+ :: Vector DMatrix -> IO DMatrix+veccat' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__veccat_TIC x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++foreign import ccall unsafe "CasADi__vecNZcat_TIC" c_CasADi__vecNZcat_TIC+ :: Ptr (CppVec (Ptr DMatrix')) -> IO (Ptr DMatrix')+vecNZcat'+ :: Vector DMatrix -> IO DMatrix+vecNZcat' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__vecNZcat_TIC x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++foreign import ccall unsafe "CasADi__flattencat_TIC" c_CasADi__flattencat_TIC+ :: Ptr (CppVec (Ptr DMatrix')) -> IO (Ptr DMatrix')+flattencat'+ :: Vector DMatrix -> IO DMatrix+flattencat' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__flattencat_TIC x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++foreign import ccall unsafe "CasADi__flattenNZcat_TIC" c_CasADi__flattenNZcat_TIC+ :: Ptr (CppVec (Ptr DMatrix')) -> IO (Ptr DMatrix')+flattenNZcat'+ :: Vector DMatrix -> IO DMatrix+flattenNZcat' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__flattenNZcat_TIC x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++foreign import ccall unsafe "CasADi__project_TIC" c_CasADi__project_TIC+ :: Ptr DMatrix' -> Ptr CRSSparsity' -> IO (Ptr DMatrix')+project'+ :: DMatrix -> CRSSparsity -> IO DMatrix+project' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__project_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++foreign import ccall unsafe "CasADi__sprank_TIC" c_CasADi__sprank_TIC+ :: Ptr DMatrix' -> IO CInt+sprank'+ :: DMatrix -> IO Int+sprank' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__sprank_TIC x0' >>= wrapReturn++foreign import ccall unsafe "CasADi__kron_TIC" c_CasADi__kron_TIC+ :: Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')+kron'+ :: DMatrix -> DMatrix -> IO DMatrix+kron' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__kron_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++foreign import ccall unsafe "CasADi__sparse_TIC_TIC" c_CasADi__sparse_TIC_TIC+ :: Ptr DMatrix' -> CDouble -> IO (Ptr DMatrix')+sparse''+ :: DMatrix -> Double -> IO DMatrix+sparse'' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__sparse_TIC_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++foreign import ccall unsafe "CasADi__sparse_TIC_TIC_TIC" c_CasADi__sparse_TIC_TIC_TIC+ :: Ptr DMatrix' -> IO (Ptr DMatrix')+sparse'''+ :: DMatrix -> IO DMatrix+sparse''' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__sparse_TIC_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++foreign import ccall unsafe "CasADi__full_TIC" c_CasADi__full_TIC+ :: Ptr DMatrix' -> IO (Ptr DMatrix')+full'+ :: DMatrix -> IO DMatrix+full' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__full_TIC x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++foreign import ccall unsafe "CasADi__trans_TIC_TIC" c_CasADi__trans_TIC_TIC+ :: Ptr SXMatrix' -> IO (Ptr SXMatrix')+trans''+ :: SXMatrix -> IO SXMatrix+trans'' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__trans_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++foreign import ccall unsafe "CasADi__mul_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__mul_TIC_TIC_TIC_TIC_TIC_TIC+ :: Ptr SXMatrix' -> Ptr SXMatrix' -> Ptr CRSSparsity' -> IO (Ptr SXMatrix')+mul''''''+ :: SXMatrix -> SXMatrix -> CRSSparsity -> IO SXMatrix+mul'''''' x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__mul_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++foreign import ccall unsafe "CasADi__mul_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__mul_TIC_TIC_TIC_TIC_TIC_TIC_TIC+ :: Ptr SXMatrix' -> Ptr SXMatrix' -> IO (Ptr SXMatrix')+mul'''''''+ :: SXMatrix -> SXMatrix -> IO SXMatrix+mul''''''' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__mul_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++foreign import ccall unsafe "CasADi__mul_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__mul_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC+ :: Ptr (CppVec (Ptr SXMatrix')) -> IO (Ptr SXMatrix')+mul''''''''+ :: Vector SXMatrix -> IO SXMatrix+mul'''''''' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__mul_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++foreign import ccall unsafe "CasADi__isConstant_TIC_TIC" c_CasADi__isConstant_TIC_TIC+ :: Ptr SXMatrix' -> IO (Ptr CppBool')+isConstant''+ :: SXMatrix -> IO Bool+isConstant'' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__isConstant_TIC_TIC x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++foreign import ccall unsafe "CasADi__isDense_TIC_TIC" c_CasADi__isDense_TIC_TIC+ :: Ptr SXMatrix' -> IO (Ptr CppBool')+isDense''+ :: SXMatrix -> IO Bool+isDense'' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__isDense_TIC_TIC x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++foreign import ccall unsafe "CasADi__isEmpty_TIC_TIC" c_CasADi__isEmpty_TIC_TIC+ :: Ptr SXMatrix' -> IO (Ptr CppBool')+isEmpty''+ :: SXMatrix -> IO Bool+isEmpty'' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__isEmpty_TIC_TIC x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++foreign import ccall unsafe "CasADi__isInteger_TIC_TIC" c_CasADi__isInteger_TIC_TIC+ :: Ptr SXMatrix' -> IO (Ptr CppBool')+isInteger''+ :: SXMatrix -> IO Bool+isInteger'' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__isInteger_TIC_TIC x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++foreign import ccall unsafe "CasADi__isScalar_TIC_TIC" c_CasADi__isScalar_TIC_TIC+ :: Ptr SXMatrix' -> IO (Ptr CppBool')+isScalar''+ :: SXMatrix -> IO Bool+isScalar'' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__isScalar_TIC_TIC x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++foreign import ccall unsafe "CasADi__isVector_TIC_TIC" c_CasADi__isVector_TIC_TIC+ :: Ptr SXMatrix' -> IO (Ptr CppBool')+isVector''+ :: SXMatrix -> IO Bool+isVector'' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__isVector_TIC_TIC x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++foreign import ccall unsafe "CasADi__isTril_TIC_TIC" c_CasADi__isTril_TIC_TIC+ :: Ptr SXMatrix' -> IO (Ptr CppBool')+isTril''+ :: SXMatrix -> IO Bool+isTril'' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__isTril_TIC_TIC x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++foreign import ccall unsafe "CasADi__isTriu_TIC_TIC" c_CasADi__isTriu_TIC_TIC+ :: Ptr SXMatrix' -> IO (Ptr CppBool')+isTriu''+ :: SXMatrix -> IO Bool+isTriu'' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__isTriu_TIC_TIC x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++foreign import ccall unsafe "CasADi__det_TIC_TIC" c_CasADi__det_TIC_TIC+ :: Ptr SXMatrix' -> IO (Ptr SX')+det''+ :: SXMatrix -> IO SX+det'' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__det_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__SX) >>= wrapReturn++foreign import ccall unsafe "CasADi__getMinor_TIC_TIC" c_CasADi__getMinor_TIC_TIC+ :: Ptr SXMatrix' -> CInt -> CInt -> IO (Ptr SX')+getMinor''+ :: SXMatrix -> Int -> Int -> IO SX+getMinor'' x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__getMinor_TIC_TIC x0' x1' x2' >>= (newForeignPtr c_delete_CasADi__SX) >>= wrapReturn++foreign import ccall unsafe "CasADi__cofactor_TIC_TIC" c_CasADi__cofactor_TIC_TIC+ :: Ptr SXMatrix' -> CInt -> CInt -> IO (Ptr SX')+cofactor''+ :: SXMatrix -> Int -> Int -> IO SX+cofactor'' x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__cofactor_TIC_TIC x0' x1' x2' >>= (newForeignPtr c_delete_CasADi__SX) >>= wrapReturn++foreign import ccall unsafe "CasADi__adj_TIC_TIC" c_CasADi__adj_TIC_TIC+ :: Ptr SXMatrix' -> IO (Ptr SXMatrix')+adj''+ :: SXMatrix -> IO SXMatrix+adj'' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__adj_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++foreign import ccall unsafe "CasADi__inv_TIC_TIC" c_CasADi__inv_TIC_TIC+ :: Ptr SXMatrix' -> IO (Ptr SXMatrix')+inv''+ :: SXMatrix -> IO SXMatrix+inv'' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__inv_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++foreign import ccall unsafe "CasADi__reshape_TIC_TIC_TIC_TIC" c_CasADi__reshape_TIC_TIC_TIC_TIC+ :: Ptr SXMatrix' -> CInt -> CInt -> IO (Ptr SXMatrix')+reshape''''+ :: SXMatrix -> Int -> Int -> IO SXMatrix+reshape'''' x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__reshape_TIC_TIC_TIC_TIC x0' x1' x2' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++foreign import ccall unsafe "CasADi__reshape_TIC_TIC_TIC_TIC_TIC" c_CasADi__reshape_TIC_TIC_TIC_TIC_TIC+ :: Ptr SXMatrix' -> Ptr CRSSparsity' -> IO (Ptr SXMatrix')+reshape'''''+ :: SXMatrix -> CRSSparsity -> IO SXMatrix+reshape''''' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__reshape_TIC_TIC_TIC_TIC_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++foreign import ccall unsafe "CasADi__vec_TIC_TIC" c_CasADi__vec_TIC_TIC+ :: Ptr SXMatrix' -> IO (Ptr SXMatrix')+vec''+ :: SXMatrix -> IO SXMatrix+vec'' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__vec_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++foreign import ccall unsafe "CasADi__flatten_TIC_TIC" c_CasADi__flatten_TIC_TIC+ :: Ptr SXMatrix' -> IO (Ptr SXMatrix')+flatten''+ :: SXMatrix -> IO SXMatrix+flatten'' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__flatten_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++foreign import ccall unsafe "CasADi__vecNZ_TIC_TIC" c_CasADi__vecNZ_TIC_TIC+ :: Ptr SXMatrix' -> IO (Ptr SXMatrix')+vecNZ''+ :: SXMatrix -> IO SXMatrix+vecNZ'' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__vecNZ_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++foreign import ccall unsafe "CasADi__flattenNZ_TIC_TIC" c_CasADi__flattenNZ_TIC_TIC+ :: Ptr SXMatrix' -> IO (Ptr SXMatrix')+flattenNZ''+ :: SXMatrix -> IO SXMatrix+flattenNZ'' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__flattenNZ_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++foreign import ccall unsafe "CasADi__blockcat_TIC_TIC" c_CasADi__blockcat_TIC_TIC+ :: Ptr (CppVecVec (Ptr SXMatrix')) -> IO (Ptr SXMatrix')+blockcat''+ :: Vector (Vector SXMatrix) -> IO SXMatrix+blockcat'' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__blockcat_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++foreign import ccall unsafe "CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC+ :: Ptr SXMatrix' -> Ptr (CppVec CInt) -> Ptr (CppVec CInt) -> IO (Ptr (CppVecVec (Ptr SXMatrix')))+blocksplit''''''''+ :: SXMatrix -> Vector Int -> Vector Int -> IO (Vector (Vector SXMatrix))+blocksplit'''''''' x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' >>= (newForeignPtr c_delete_std__vector_std__vector_CasADi__Matrix_CasADi__SX___) >>= wrapReturn++foreign import ccall unsafe "CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC+ :: Ptr SXMatrix' -> CInt -> CInt -> IO (Ptr (CppVecVec (Ptr SXMatrix')))+blocksplit'''''''''+ :: SXMatrix -> Int -> Int -> IO (Vector (Vector SXMatrix))+blocksplit''''''''' x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' >>= (newForeignPtr c_delete_std__vector_std__vector_CasADi__Matrix_CasADi__SX___) >>= wrapReturn++foreign import ccall unsafe "CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC+ :: Ptr SXMatrix' -> CInt -> IO (Ptr (CppVecVec (Ptr SXMatrix')))+blocksplit''''''''''+ :: SXMatrix -> Int -> IO (Vector (Vector SXMatrix))+blocksplit'''''''''' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' >>= (newForeignPtr c_delete_std__vector_std__vector_CasADi__Matrix_CasADi__SX___) >>= wrapReturn++foreign import ccall unsafe "CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC+ :: Ptr SXMatrix' -> IO (Ptr (CppVecVec (Ptr SXMatrix')))+blocksplit'''''''''''+ :: SXMatrix -> IO (Vector (Vector SXMatrix))+blocksplit''''''''''' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' >>= (newForeignPtr c_delete_std__vector_std__vector_CasADi__Matrix_CasADi__SX___) >>= wrapReturn++foreign import ccall unsafe "CasADi__horzcat_TIC_TIC" c_CasADi__horzcat_TIC_TIC+ :: Ptr (CppVec (Ptr SXMatrix')) -> IO (Ptr SXMatrix')+horzcat''+ :: Vector SXMatrix -> IO SXMatrix+horzcat'' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__horzcat_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++foreign import ccall unsafe "CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC_TIC+ :: Ptr SXMatrix' -> Ptr (CppVec CInt) -> IO (Ptr (CppVec (Ptr SXMatrix')))+horzsplit''''''+ :: SXMatrix -> Vector Int -> IO (Vector SXMatrix)+horzsplit'''''' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' >>= (newForeignPtr c_delete_std__vector_CasADi__Matrix_CasADi__SX__) >>= wrapReturn++foreign import ccall unsafe "CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC+ :: Ptr SXMatrix' -> CInt -> IO (Ptr (CppVec (Ptr SXMatrix')))+horzsplit'''''''+ :: SXMatrix -> Int -> IO (Vector SXMatrix)+horzsplit''''''' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' >>= (newForeignPtr c_delete_std__vector_CasADi__Matrix_CasADi__SX__) >>= wrapReturn++foreign import ccall unsafe "CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC+ :: Ptr SXMatrix' -> IO (Ptr (CppVec (Ptr SXMatrix')))+horzsplit''''''''+ :: SXMatrix -> IO (Vector SXMatrix)+horzsplit'''''''' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' >>= (newForeignPtr c_delete_std__vector_CasADi__Matrix_CasADi__SX__) >>= wrapReturn++foreign import ccall unsafe "CasADi__vertcat_TIC_TIC" c_CasADi__vertcat_TIC_TIC+ :: Ptr (CppVec (Ptr SXMatrix')) -> IO (Ptr SXMatrix')+vertcat''+ :: Vector SXMatrix -> IO SXMatrix+vertcat'' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__vertcat_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++foreign import ccall unsafe "CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC_TIC+ :: Ptr SXMatrix' -> Ptr (CppVec CInt) -> IO (Ptr (CppVec (Ptr SXMatrix')))+vertsplit''''''+ :: SXMatrix -> Vector Int -> IO (Vector SXMatrix)+vertsplit'''''' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' >>= (newForeignPtr c_delete_std__vector_CasADi__Matrix_CasADi__SX__) >>= wrapReturn++foreign import ccall unsafe "CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC+ :: Ptr SXMatrix' -> CInt -> IO (Ptr (CppVec (Ptr SXMatrix')))+vertsplit'''''''+ :: SXMatrix -> Int -> IO (Vector SXMatrix)+vertsplit''''''' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' >>= (newForeignPtr c_delete_std__vector_CasADi__Matrix_CasADi__SX__) >>= wrapReturn++foreign import ccall unsafe "CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC+ :: Ptr SXMatrix' -> IO (Ptr (CppVec (Ptr SXMatrix')))+vertsplit''''''''+ :: SXMatrix -> IO (Vector SXMatrix)+vertsplit'''''''' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' >>= (newForeignPtr c_delete_std__vector_CasADi__Matrix_CasADi__SX__) >>= wrapReturn++foreign import ccall unsafe "CasADi__inner_prod_TIC_TIC" c_CasADi__inner_prod_TIC_TIC+ :: Ptr SXMatrix' -> Ptr SXMatrix' -> IO (Ptr SXMatrix')+inner_prod''+ :: SXMatrix -> SXMatrix -> IO SXMatrix+inner_prod'' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__inner_prod_TIC_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++foreign import ccall unsafe "CasADi__outer_prod_TIC_TIC" c_CasADi__outer_prod_TIC_TIC+ :: Ptr SXMatrix' -> Ptr SXMatrix' -> IO (Ptr SXMatrix')+outer_prod''+ :: SXMatrix -> SXMatrix -> IO SXMatrix+outer_prod'' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__outer_prod_TIC_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++foreign import ccall unsafe "CasADi__norm_1_TIC_TIC" c_CasADi__norm_1_TIC_TIC+ :: Ptr SXMatrix' -> IO (Ptr SXMatrix')+norm_1''+ :: SXMatrix -> IO SXMatrix+norm_1'' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__norm_1_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++foreign import ccall unsafe "CasADi__norm_2_TIC_TIC" c_CasADi__norm_2_TIC_TIC+ :: Ptr SXMatrix' -> IO (Ptr SXMatrix')+norm_2''+ :: SXMatrix -> IO SXMatrix+norm_2'' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__norm_2_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++foreign import ccall unsafe "CasADi__norm_inf_TIC_TIC" c_CasADi__norm_inf_TIC_TIC+ :: Ptr SXMatrix' -> IO (Ptr SXMatrix')+norm_inf''+ :: SXMatrix -> IO SXMatrix+norm_inf'' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__norm_inf_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++foreign import ccall unsafe "CasADi__norm_F_TIC_TIC" c_CasADi__norm_F_TIC_TIC+ :: Ptr SXMatrix' -> IO (Ptr SXMatrix')+norm_F''+ :: SXMatrix -> IO SXMatrix+norm_F'' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__norm_F_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++foreign import ccall unsafe "CasADi__qr_TIC_TIC" c_CasADi__qr_TIC_TIC+ :: Ptr SXMatrix' -> Ptr SXMatrix' -> Ptr SXMatrix' -> IO ()+qr''+ :: SXMatrix -> SXMatrix -> SXMatrix -> IO ()+qr'' x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__qr_TIC_TIC x0' x1' x2' >>= wrapReturn++foreign import ccall unsafe "CasADi__nullspace_TIC_TIC" c_CasADi__nullspace_TIC_TIC+ :: Ptr SXMatrix' -> IO (Ptr SXMatrix')+nullspace''+ :: SXMatrix -> IO SXMatrix+nullspace'' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__nullspace_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++foreign import ccall unsafe "CasADi__solve_TIC_TIC" c_CasADi__solve_TIC_TIC+ :: Ptr SXMatrix' -> Ptr SXMatrix' -> IO (Ptr SXMatrix')+solve''+ :: SXMatrix -> SXMatrix -> IO SXMatrix+solve'' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__solve_TIC_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++foreign import ccall unsafe "CasADi__pinv_TIC_TIC" c_CasADi__pinv_TIC_TIC+ :: Ptr SXMatrix' -> IO (Ptr SXMatrix')+pinv''+ :: SXMatrix -> IO SXMatrix+pinv'' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__pinv_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++foreign import ccall unsafe "CasADi__isZero_TIC_TIC" c_CasADi__isZero_TIC_TIC+ :: Ptr SXMatrix' -> IO (Ptr CppBool')+isZero''+ :: SXMatrix -> IO Bool+isZero'' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__isZero_TIC_TIC x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++foreign import ccall unsafe "CasADi__isOne_TIC_TIC" c_CasADi__isOne_TIC_TIC+ :: Ptr SXMatrix' -> IO (Ptr CppBool')+isOne''+ :: SXMatrix -> IO Bool+isOne'' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__isOne_TIC_TIC x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++foreign import ccall unsafe "CasADi__isMinusOne_TIC_TIC" c_CasADi__isMinusOne_TIC_TIC+ :: Ptr SXMatrix' -> IO (Ptr CppBool')+isMinusOne''+ :: SXMatrix -> IO Bool+isMinusOne'' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__isMinusOne_TIC_TIC x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++foreign import ccall unsafe "CasADi__isIdentity_TIC_TIC" c_CasADi__isIdentity_TIC_TIC+ :: Ptr SXMatrix' -> IO (Ptr CppBool')+isIdentity''+ :: SXMatrix -> IO Bool+isIdentity'' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__isIdentity_TIC_TIC x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++foreign import ccall unsafe "CasADi__nnz_TIC_TIC" c_CasADi__nnz_TIC_TIC+ :: Ptr SXMatrix' -> IO CInt+nnz''+ :: SXMatrix -> IO Int+nnz'' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__nnz_TIC_TIC x0' >>= wrapReturn++foreign import ccall unsafe "CasADi__nnz_sym_TIC_TIC" c_CasADi__nnz_sym_TIC_TIC+ :: Ptr SXMatrix' -> IO CInt+nnz_sym''+ :: SXMatrix -> IO Int+nnz_sym'' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__nnz_sym_TIC_TIC x0' >>= wrapReturn++foreign import ccall unsafe "CasADi__isEqual_TIC_TIC" c_CasADi__isEqual_TIC_TIC+ :: Ptr SXMatrix' -> Ptr SXMatrix' -> IO (Ptr CppBool')+isEqual''+ :: SXMatrix -> SXMatrix -> IO Bool+isEqual'' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__isEqual_TIC_TIC x0' x1' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++foreign import ccall unsafe "CasADi__repmat_TIC_TIC" c_CasADi__repmat_TIC_TIC+ :: Ptr SXMatrix' -> CInt -> CInt -> IO (Ptr SXMatrix')+repmat''+ :: SXMatrix -> Int -> Int -> IO SXMatrix+repmat'' x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__repmat_TIC_TIC x0' x1' x2' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++foreign import ccall unsafe "CasADi__getSparseTriplet_TIC_TIC" c_CasADi__getSparseTriplet_TIC_TIC+ :: Ptr SXMatrix' -> IO (Ptr (CppVecVec CInt))+getSparseTriplet''+ :: SXMatrix -> IO (Vector (Vector Int))+getSparseTriplet'' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__getSparseTriplet_TIC_TIC x0' >>= (newForeignPtr c_delete_std__vector_std__vector_int__) >>= wrapReturn++foreign import ccall unsafe "CasADi__unite_TIC_TIC" c_CasADi__unite_TIC_TIC+ :: Ptr SXMatrix' -> Ptr SXMatrix' -> IO (Ptr SXMatrix')+unite''+ :: SXMatrix -> SXMatrix -> IO SXMatrix+unite'' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__unite_TIC_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++foreign import ccall unsafe "CasADi__sumCols_TIC_TIC" c_CasADi__sumCols_TIC_TIC+ :: Ptr SXMatrix' -> IO (Ptr SXMatrix')+sumCols''+ :: SXMatrix -> IO SXMatrix+sumCols'' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__sumCols_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++foreign import ccall unsafe "CasADi__sumRows_TIC_TIC" c_CasADi__sumRows_TIC_TIC+ :: Ptr SXMatrix' -> IO (Ptr SXMatrix')+sumRows''+ :: SXMatrix -> IO SXMatrix+sumRows'' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__sumRows_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++foreign import ccall unsafe "CasADi__sumAll_TIC_TIC" c_CasADi__sumAll_TIC_TIC+ :: Ptr SXMatrix' -> IO (Ptr SXMatrix')+sumAll''+ :: SXMatrix -> IO SXMatrix+sumAll'' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__sumAll_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++foreign import ccall unsafe "CasADi__trace_TIC_TIC" c_CasADi__trace_TIC_TIC+ :: Ptr SXMatrix' -> IO (Ptr SX')+trace''+ :: SXMatrix -> IO SX+trace'' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__trace_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__SX) >>= wrapReturn++foreign import ccall unsafe "CasADi__makeDense_TIC_TIC" c_CasADi__makeDense_TIC_TIC+ :: Ptr SXMatrix' -> IO ()+makeDense''+ :: SXMatrix -> IO ()+makeDense'' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__makeDense_TIC_TIC x0' >>= wrapReturn++foreign import ccall unsafe "CasADi__densify_TIC_TIC" c_CasADi__densify_TIC_TIC+ :: Ptr SXMatrix' -> IO (Ptr SXMatrix')+densify''+ :: SXMatrix -> IO SXMatrix+densify'' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__densify_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++foreign import ccall unsafe "CasADi__makeSparse_TIC_TIC_TIC_TIC" c_CasADi__makeSparse_TIC_TIC_TIC_TIC+ :: Ptr SXMatrix' -> CDouble -> IO ()+makeSparse''''+ :: SXMatrix -> Double -> IO ()+makeSparse'''' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__makeSparse_TIC_TIC_TIC_TIC x0' x1' >>= wrapReturn++foreign import ccall unsafe "CasADi__makeSparse_TIC_TIC_TIC_TIC_TIC" c_CasADi__makeSparse_TIC_TIC_TIC_TIC_TIC+ :: Ptr SXMatrix' -> IO ()+makeSparse'''''+ :: SXMatrix -> IO ()+makeSparse''''' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__makeSparse_TIC_TIC_TIC_TIC_TIC x0' >>= wrapReturn++foreign import ccall unsafe "CasADi__hasNonStructuralZeros_TIC_TIC" c_CasADi__hasNonStructuralZeros_TIC_TIC+ :: Ptr SXMatrix' -> IO (Ptr CppBool')+hasNonStructuralZeros''+ :: SXMatrix -> IO Bool+hasNonStructuralZeros'' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__hasNonStructuralZeros_TIC_TIC x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++foreign import ccall unsafe "CasADi__diag_TIC_TIC" c_CasADi__diag_TIC_TIC+ :: Ptr SXMatrix' -> IO (Ptr SXMatrix')+diag''+ :: SXMatrix -> IO SXMatrix+diag'' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__diag_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++foreign import ccall unsafe "CasADi__blkdiag_TIC_TIC" c_CasADi__blkdiag_TIC_TIC+ :: Ptr (CppVec (Ptr SXMatrix')) -> IO (Ptr SXMatrix')+blkdiag''+ :: Vector SXMatrix -> IO SXMatrix+blkdiag'' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__blkdiag_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++foreign import ccall unsafe "CasADi__polyval_TIC_TIC" c_CasADi__polyval_TIC_TIC+ :: Ptr SXMatrix' -> Ptr SXMatrix' -> IO (Ptr SXMatrix')+polyval''+ :: SXMatrix -> SXMatrix -> IO SXMatrix+polyval'' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__polyval_TIC_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++foreign import ccall unsafe "CasADi__addMultiple_TIC_TIC_TIC_TIC" c_CasADi__addMultiple_TIC_TIC_TIC_TIC+ :: Ptr SXMatrix' -> Ptr (CppVec (Ptr SX')) -> Ptr (CppVec (Ptr SX')) -> Ptr CppBool' -> IO ()+addMultiple''''+ :: SXMatrix -> Vector SX -> Vector SX -> Bool -> IO ()+addMultiple'''' x0 x1 x2 x3 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ withMarshal x3 $ \x3' ->+ c_CasADi__addMultiple_TIC_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn++foreign import ccall unsafe "CasADi__addMultiple_TIC_TIC_TIC_TIC_TIC" c_CasADi__addMultiple_TIC_TIC_TIC_TIC_TIC+ :: Ptr SXMatrix' -> Ptr (CppVec (Ptr SX')) -> Ptr (CppVec (Ptr SX')) -> IO ()+addMultiple'''''+ :: SXMatrix -> Vector SX -> Vector SX -> IO ()+addMultiple''''' x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__addMultiple_TIC_TIC_TIC_TIC_TIC x0' x1' x2' >>= wrapReturn++foreign import ccall unsafe "CasADi__veccat_TIC_TIC" c_CasADi__veccat_TIC_TIC+ :: Ptr (CppVec (Ptr SXMatrix')) -> IO (Ptr SXMatrix')+veccat''+ :: Vector SXMatrix -> IO SXMatrix+veccat'' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__veccat_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++foreign import ccall unsafe "CasADi__vecNZcat_TIC_TIC" c_CasADi__vecNZcat_TIC_TIC+ :: Ptr (CppVec (Ptr SXMatrix')) -> IO (Ptr SXMatrix')+vecNZcat''+ :: Vector SXMatrix -> IO SXMatrix+vecNZcat'' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__vecNZcat_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++foreign import ccall unsafe "CasADi__flattencat_TIC_TIC" c_CasADi__flattencat_TIC_TIC+ :: Ptr (CppVec (Ptr SXMatrix')) -> IO (Ptr SXMatrix')+flattencat''+ :: Vector SXMatrix -> IO SXMatrix+flattencat'' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__flattencat_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++foreign import ccall unsafe "CasADi__flattenNZcat_TIC_TIC" c_CasADi__flattenNZcat_TIC_TIC+ :: Ptr (CppVec (Ptr SXMatrix')) -> IO (Ptr SXMatrix')+flattenNZcat''+ :: Vector SXMatrix -> IO SXMatrix+flattenNZcat'' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__flattenNZcat_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++foreign import ccall unsafe "CasADi__project_TIC_TIC" c_CasADi__project_TIC_TIC+ :: Ptr SXMatrix' -> Ptr CRSSparsity' -> IO (Ptr SXMatrix')+project''+ :: SXMatrix -> CRSSparsity -> IO SXMatrix+project'' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__project_TIC_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++foreign import ccall unsafe "CasADi__sprank_TIC_TIC" c_CasADi__sprank_TIC_TIC+ :: Ptr SXMatrix' -> IO CInt+sprank''+ :: SXMatrix -> IO Int+sprank'' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__sprank_TIC_TIC x0' >>= wrapReturn++foreign import ccall unsafe "CasADi__kron_TIC_TIC" c_CasADi__kron_TIC_TIC+ :: Ptr SXMatrix' -> Ptr SXMatrix' -> IO (Ptr SXMatrix')+kron''+ :: SXMatrix -> SXMatrix -> IO SXMatrix+kron'' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__kron_TIC_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++foreign import ccall unsafe "CasADi__sparse_TIC_TIC_TIC_TIC" c_CasADi__sparse_TIC_TIC_TIC_TIC+ :: Ptr SXMatrix' -> CDouble -> IO (Ptr SXMatrix')+sparse''''+ :: SXMatrix -> Double -> IO SXMatrix+sparse'''' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__sparse_TIC_TIC_TIC_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++foreign import ccall unsafe "CasADi__sparse_TIC_TIC_TIC_TIC_TIC" c_CasADi__sparse_TIC_TIC_TIC_TIC_TIC+ :: Ptr SXMatrix' -> IO (Ptr SXMatrix')+sparse'''''+ :: SXMatrix -> IO SXMatrix+sparse''''' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__sparse_TIC_TIC_TIC_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++foreign import ccall unsafe "CasADi__full_TIC_TIC" c_CasADi__full_TIC_TIC+ :: Ptr SXMatrix' -> IO (Ptr SXMatrix')+full''+ :: SXMatrix -> IO SXMatrix+full'' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__full_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++foreign import ccall unsafe "CasADi__logic_and" c_CasADi__logic_and+ :: CInt -> CInt -> IO CInt+{-|+>Logical and, returns (an expression evaluating to) 1 if both expressions are+>nonzero and 0 otherwise.+-}+logic_and+ :: Int -> Int -> IO Int+logic_and x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__logic_and x0' x1' >>= wrapReturn++foreign import ccall unsafe "CasADi__logic_or" c_CasADi__logic_or+ :: CInt -> CInt -> IO CInt+{-|+>Logical or, returns (an expression evaluating to) 1 if at least one+>expression is nonzero and 0 otherwise.+-}+logic_or+ :: Int -> Int -> IO Int+logic_or x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__logic_or x0' x1' >>= wrapReturn++foreign import ccall unsafe "CasADi__logic_not" c_CasADi__logic_not+ :: CInt -> IO CInt+{-|+>Logical not, returns (an expression evaluating to) 1 if expression is zero+>and 0 otherwise.+-}+logic_not+ :: Int -> IO Int+logic_not x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__logic_not x0' >>= wrapReturn++foreign import ccall unsafe "CasADi__logic_and_TIC" c_CasADi__logic_and_TIC+ :: CDouble -> CDouble -> IO CDouble+logic_and'+ :: Double -> Double -> IO Double+logic_and' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__logic_and_TIC x0' x1' >>= wrapReturn++foreign import ccall unsafe "CasADi__logic_or_TIC" c_CasADi__logic_or_TIC+ :: CDouble -> CDouble -> IO CDouble+logic_or'+ :: Double -> Double -> IO Double+logic_or' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__logic_or_TIC x0' x1' >>= wrapReturn++foreign import ccall unsafe "CasADi__logic_not_TIC" c_CasADi__logic_not_TIC+ :: CDouble -> IO CDouble+logic_not'+ :: Double -> IO Double+logic_not' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__logic_not_TIC x0' >>= wrapReturn++foreign import ccall unsafe "CasADi__logic_and_TIC_TIC_TIC" c_CasADi__logic_and_TIC_TIC_TIC+ :: Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')+logic_and'''+ :: DMatrix -> DMatrix -> IO DMatrix+logic_and''' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__logic_and_TIC_TIC_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++foreign import ccall unsafe "CasADi__logic_or_TIC_TIC_TIC" c_CasADi__logic_or_TIC_TIC_TIC+ :: Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')+logic_or'''+ :: DMatrix -> DMatrix -> IO DMatrix+logic_or''' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__logic_or_TIC_TIC_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++foreign import ccall unsafe "CasADi__logic_not_TIC_TIC_TIC" c_CasADi__logic_not_TIC_TIC_TIC+ :: Ptr DMatrix' -> IO (Ptr DMatrix')+logic_not'''+ :: DMatrix -> IO DMatrix+logic_not''' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__logic_not_TIC_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++foreign import ccall unsafe "CasADi__logic_and_TIC_TIC_TIC_TIC" c_CasADi__logic_and_TIC_TIC_TIC_TIC+ :: Ptr SXMatrix' -> Ptr SXMatrix' -> IO (Ptr SXMatrix')+logic_and''''+ :: SXMatrix -> SXMatrix -> IO SXMatrix+logic_and'''' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__logic_and_TIC_TIC_TIC_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++foreign import ccall unsafe "CasADi__logic_or_TIC_TIC_TIC_TIC" c_CasADi__logic_or_TIC_TIC_TIC_TIC+ :: Ptr SXMatrix' -> Ptr SXMatrix' -> IO (Ptr SXMatrix')+logic_or''''+ :: SXMatrix -> SXMatrix -> IO SXMatrix+logic_or'''' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__logic_or_TIC_TIC_TIC_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++foreign import ccall unsafe "CasADi__logic_not_TIC_TIC_TIC_TIC" c_CasADi__logic_not_TIC_TIC_TIC_TIC+ :: Ptr SXMatrix' -> IO (Ptr SXMatrix')+logic_not''''+ :: SXMatrix -> IO SXMatrix+logic_not'''' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__logic_not_TIC_TIC_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++foreign import ccall unsafe "CasADi__logic_and_TIC_TIC_TIC_TIC_TIC" c_CasADi__logic_and_TIC_TIC_TIC_TIC_TIC+ :: Ptr MX' -> Ptr MX' -> IO (Ptr MX')+logic_and'''''+ :: MX -> MX -> IO MX+logic_and''''' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__logic_and_TIC_TIC_TIC_TIC_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++foreign import ccall unsafe "CasADi__logic_or_TIC_TIC_TIC_TIC_TIC" c_CasADi__logic_or_TIC_TIC_TIC_TIC_TIC+ :: Ptr MX' -> Ptr MX' -> IO (Ptr MX')+logic_or'''''+ :: MX -> MX -> IO MX+logic_or''''' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__logic_or_TIC_TIC_TIC_TIC_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++foreign import ccall unsafe "CasADi__logic_not_TIC_TIC_TIC_TIC_TIC" c_CasADi__logic_not_TIC_TIC_TIC_TIC_TIC+ :: Ptr MX' -> IO (Ptr MX')+logic_not'''''+ :: MX -> IO MX+logic_not''''' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__logic_not_TIC_TIC_TIC_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++foreign import ccall unsafe "CasADi__logic_and_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__logic_and_TIC_TIC_TIC_TIC_TIC_TIC+ :: Ptr SX' -> Ptr SX' -> IO (Ptr SX')+logic_and''''''+ :: SX -> SX -> IO SX+logic_and'''''' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__logic_and_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__SX) >>= wrapReturn++foreign import ccall unsafe "CasADi__logic_or_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__logic_or_TIC_TIC_TIC_TIC_TIC_TIC+ :: Ptr SX' -> Ptr SX' -> IO (Ptr SX')+logic_or''''''+ :: SX -> SX -> IO SX+logic_or'''''' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__logic_or_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__SX) >>= wrapReturn++foreign import ccall unsafe "CasADi__logic_not_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__logic_not_TIC_TIC_TIC_TIC_TIC_TIC+ :: Ptr SX' -> IO (Ptr SX')+logic_not''''''+ :: SX -> IO SX+logic_not'''''' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__logic_not_TIC_TIC_TIC_TIC_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__SX) >>= wrapReturn++foreign import ccall unsafe "CasADi__hash_combine" c_CasADi__hash_combine+ :: CSize -> Ptr (CppVec CInt) -> IO ()+{-|+>Generate a hash value incrementally (function taken from boost)+-}+hash_combine+ :: CSize -> Vector Int -> IO ()+hash_combine x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__hash_combine x0' x1' >>= wrapReturn++foreign import ccall unsafe "CasADi__hash_sparsity" c_CasADi__hash_sparsity+ :: CInt -> CInt -> Ptr (CppVec CInt) -> Ptr (CppVec CInt) -> IO CSize+{-|+>Hash a sparsity pattern.+-}+hash_sparsity+ :: Int -> Int -> Vector Int -> Vector Int -> IO CSize+hash_sparsity x0 x1 x2 x3 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ withMarshal x3 $ \x3' ->+ c_CasADi__hash_sparsity x0' x1' x2' x3' >>= wrapReturn++foreign import ccall unsafe "CasADi__sp_dense" c_CasADi__sp_dense+ :: CInt -> CInt -> IO (Ptr CRSSparsity')+{-|+>Create a dense rectangular sparsity pattern.+-}+sp_dense+ :: Int -> Int -> IO CRSSparsity+sp_dense x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__sp_dense x0' x1' >>= (newForeignPtr c_delete_CasADi__CRSSparsity) >>= wrapReturn++foreign import ccall unsafe "CasADi__sp_dense_TIC" c_CasADi__sp_dense_TIC+ :: CInt -> IO (Ptr CRSSparsity')+sp_dense'+ :: Int -> IO CRSSparsity+sp_dense' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__sp_dense_TIC x0' >>= (newForeignPtr c_delete_CasADi__CRSSparsity) >>= wrapReturn++foreign import ccall unsafe "CasADi__sp_sparse" c_CasADi__sp_sparse+ :: CInt -> CInt -> IO (Ptr CRSSparsity')+{-|+>> CRSSparsity CasADi::sp_sparse(int n, int m=1)+>------------------------------------------------------------------------+>+>Create a sparse rectangular sparsity pattern.+>+>> CRSSparsity CasADi::sp_sparse(const std::pair< int, int > &nm)+>------------------------------------------------------------------------+>+>Create a dense rectangular sparsity pattern.+-}+sp_sparse+ :: Int -> Int -> IO CRSSparsity+sp_sparse x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__sp_sparse x0' x1' >>= (newForeignPtr c_delete_CasADi__CRSSparsity) >>= wrapReturn++foreign import ccall unsafe "CasADi__sp_sparse_TIC" c_CasADi__sp_sparse_TIC+ :: CInt -> IO (Ptr CRSSparsity')+sp_sparse'+ :: Int -> IO CRSSparsity+sp_sparse' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__sp_sparse_TIC x0' >>= (newForeignPtr c_delete_CasADi__CRSSparsity) >>= wrapReturn++foreign import ccall unsafe "CasADi__sp_unit" c_CasADi__sp_unit+ :: CInt -> CInt -> IO (Ptr CRSSparsity')+{-|+>Create the sparsity pattern for a unit vector of length n and a nonzero on+>position el.+-}+sp_unit+ :: Int -> Int -> IO CRSSparsity+sp_unit x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__sp_unit x0' x1' >>= (newForeignPtr c_delete_CasADi__CRSSparsity) >>= wrapReturn++foreign import ccall unsafe "CasADi__sp_tril" c_CasADi__sp_tril+ :: CInt -> IO (Ptr CRSSparsity')+{-|+>Create a lower triangular square sparsity pattern.+>+>See: lowerSparsity+-}+sp_tril+ :: Int -> IO CRSSparsity+sp_tril x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__sp_tril x0' >>= (newForeignPtr c_delete_CasADi__CRSSparsity) >>= wrapReturn++foreign import ccall unsafe "CasADi__sp_diag" c_CasADi__sp_diag+ :: CInt -> IO (Ptr CRSSparsity')+{-|+>Create diagonal square sparsity pattern.+-}+sp_diag+ :: Int -> IO CRSSparsity+sp_diag x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__sp_diag x0' >>= (newForeignPtr c_delete_CasADi__CRSSparsity) >>= wrapReturn++foreign import ccall unsafe "CasADi__sp_band" c_CasADi__sp_band+ :: CInt -> CInt -> IO (Ptr CRSSparsity')+{-|+>Create a single band in a square sparsity pattern.+>+>sp_band(n,0) is equivalent to sp_diag(n) sp_band(n,-1) has a band below the+>diagonal+>+>Parameters:+>-----------+>+>p: indicate+-}+sp_band+ :: Int -> Int -> IO CRSSparsity+sp_band x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__sp_band x0' x1' >>= (newForeignPtr c_delete_CasADi__CRSSparsity) >>= wrapReturn++foreign import ccall unsafe "CasADi__sp_banded" c_CasADi__sp_banded+ :: CInt -> CInt -> IO (Ptr CRSSparsity')+{-|+>Create banded square sparsity pattern.+>+>sp_band(n,0) is equivalent to sp_diag(n) sp_band(n,1) is tri-diagonal+>matrix+-}+sp_banded+ :: Int -> Int -> IO CRSSparsity+sp_banded x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__sp_banded x0' x1' >>= (newForeignPtr c_delete_CasADi__CRSSparsity) >>= wrapReturn++foreign import ccall unsafe "CasADi__sp_rowcol" c_CasADi__sp_rowcol+ :: Ptr (CppVec CInt) -> Ptr (CppVec CInt) -> CInt -> CInt -> IO (Ptr CRSSparsity')+{-|+>Construct a block sparsity pattern from (row,col) vectors.+-}+sp_rowcol+ :: Vector Int -> Vector Int -> Int -> Int -> IO CRSSparsity+sp_rowcol x0 x1 x2 x3 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ withMarshal x3 $ \x3' ->+ c_CasADi__sp_rowcol x0' x1' x2' x3' >>= (newForeignPtr c_delete_CasADi__CRSSparsity) >>= wrapReturn++foreign import ccall unsafe "CasADi__getNZDense" c_CasADi__getNZDense+ :: Ptr CRSSparsity' -> IO (Ptr (CppVec CInt))+{-|+>Get the indices of all non-zero elements as they would appear in a Dense+>matrix A : DenseMatrix 4 x 3 B : SparseMatrix 4 x 3 , 5 structural non-+>zeros.+>+>k = getNZDense(A) A[k] will contain the elements of A that are non- zero in+>B+-}+getNZDense+ :: CRSSparsity -> IO (Vector Int)+getNZDense x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__getNZDense x0' >>= (newForeignPtr c_delete_std__vector_int_) >>= wrapReturn++foreign import ccall unsafe "CasADi__reshape_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__reshape_TIC_TIC_TIC_TIC_TIC_TIC+ :: Ptr CRSSparsity' -> CInt -> CInt -> IO (Ptr CRSSparsity')+reshape''''''+ :: CRSSparsity -> Int -> Int -> IO CRSSparsity+reshape'''''' x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__reshape_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' >>= (newForeignPtr c_delete_CasADi__CRSSparsity) >>= wrapReturn++foreign import ccall unsafe "CasADi__vec_TIC_TIC_TIC" c_CasADi__vec_TIC_TIC_TIC+ :: Ptr CRSSparsity' -> IO (Ptr CRSSparsity')+vec'''+ :: CRSSparsity -> IO CRSSparsity+vec''' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__vec_TIC_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__CRSSparsity) >>= wrapReturn++foreign import ccall unsafe "CasADi__trans_TIC_TIC_TIC" c_CasADi__trans_TIC_TIC_TIC+ :: Ptr CRSSparsity' -> IO (Ptr CRSSparsity')+trans'''+ :: CRSSparsity -> IO CRSSparsity+trans''' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__trans_TIC_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__CRSSparsity) >>= wrapReturn++foreign import ccall unsafe "CasADi__lowerSparsity" c_CasADi__lowerSparsity+ :: Ptr CRSSparsity' -> Ptr CppBool' -> IO (Ptr CRSSparsity')+{-|+>Return the lower part of the sparsity pattern.+>+>Parameters:+>-----------+>+>includeDiagonal: specify wether the diagonal must be part of the result+>+>See: sp_tril+-}+lowerSparsity+ :: CRSSparsity -> Bool -> IO CRSSparsity+lowerSparsity x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__lowerSparsity x0' x1' >>= (newForeignPtr c_delete_CasADi__CRSSparsity) >>= wrapReturn++foreign import ccall unsafe "CasADi__lowerSparsity_TIC" c_CasADi__lowerSparsity_TIC+ :: Ptr CRSSparsity' -> IO (Ptr CRSSparsity')+lowerSparsity'+ :: CRSSparsity -> IO CRSSparsity+lowerSparsity' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__lowerSparsity_TIC x0' >>= (newForeignPtr c_delete_CasADi__CRSSparsity) >>= wrapReturn++foreign import ccall unsafe "CasADi__lowerNZ" c_CasADi__lowerNZ+ :: Ptr CRSSparsity' -> IO (Ptr (CppVec CInt))+{-|+>Return the non-zero entries that make up the lower part of the provided+>matrix.+-}+lowerNZ+ :: CRSSparsity -> IO (Vector Int)+lowerNZ x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__lowerNZ x0' >>= (newForeignPtr c_delete_std__vector_int_) >>= wrapReturn++foreign import ccall unsafe "CasADi__sp_triplet" c_CasADi__sp_triplet+ :: CInt -> CInt -> Ptr (CppVec CInt) -> Ptr (CppVec CInt) -> Ptr (CppVec CInt) -> Ptr CppBool' -> IO (Ptr CRSSparsity')+{-|+>> CRSSparsity CasADi::sp_triplet(int n, int m, const std::vector< int > &row, const std::vector< int > &col, std::vector< int > &mapping, bool invert_mapping=false)+>------------------------------------------------------------------------+>+>Create a sparsity pattern given the nonzeros in sparse triplet form.+>+>> CRSSparsity CasADi::sp_triplet(int n, int m, const std::vector< int > &row, const std::vector< int > &col)+>------------------------------------------------------------------------+>+>Create a sparsity pattern given the nonzeros in sparse triplet form (no+>nonzero mapping) columns_are_sorted==true means that the column entries+>already in increasing order for each row and without any duplicates.+-}+sp_triplet+ :: Int -> Int -> Vector Int -> Vector Int -> Vector Int -> Bool -> IO CRSSparsity+sp_triplet x0 x1 x2 x3 x4 x5 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ withMarshal x3 $ \x3' ->+ withMarshal x4 $ \x4' ->+ withMarshal x5 $ \x5' ->+ c_CasADi__sp_triplet x0' x1' x2' x3' x4' x5' >>= (newForeignPtr c_delete_CasADi__CRSSparsity) >>= wrapReturn++foreign import ccall unsafe "CasADi__sp_triplet_TIC" c_CasADi__sp_triplet_TIC+ :: CInt -> CInt -> Ptr (CppVec CInt) -> Ptr (CppVec CInt) -> Ptr (CppVec CInt) -> IO (Ptr CRSSparsity')+sp_triplet'+ :: Int -> Int -> Vector Int -> Vector Int -> Vector Int -> IO CRSSparsity+sp_triplet' x0 x1 x2 x3 x4 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ withMarshal x3 $ \x3' ->+ withMarshal x4 $ \x4' ->+ c_CasADi__sp_triplet_TIC x0' x1' x2' x3' x4' >>= (newForeignPtr c_delete_CasADi__CRSSparsity) >>= wrapReturn++foreign import ccall unsafe "CasADi__sp_triplet_TIC_TIC" c_CasADi__sp_triplet_TIC_TIC+ :: CInt -> CInt -> Ptr (CppVec CInt) -> Ptr (CppVec CInt) -> IO (Ptr CRSSparsity')+sp_triplet''+ :: Int -> Int -> Vector Int -> Vector Int -> IO CRSSparsity+sp_triplet'' x0 x1 x2 x3 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ withMarshal x3 $ \x3' ->+ c_CasADi__sp_triplet_TIC_TIC x0' x1' x2' x3' >>= (newForeignPtr c_delete_CasADi__CRSSparsity) >>= wrapReturn++foreign import ccall unsafe "CasADi__mul_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__mul_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC+ :: Ptr CRSSparsity' -> Ptr CRSSparsity' -> IO (Ptr CRSSparsity')+mul'''''''''+ :: CRSSparsity -> CRSSparsity -> IO CRSSparsity+mul''''''''' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__mul_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__CRSSparsity) >>= wrapReturn++foreign import ccall unsafe "CasADi__vertcat_TIC_TIC_TIC" c_CasADi__vertcat_TIC_TIC_TIC+ :: Ptr (CppVec (Ptr CRSSparsity')) -> IO (Ptr CRSSparsity')+vertcat'''+ :: Vector CRSSparsity -> IO CRSSparsity+vertcat''' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__vertcat_TIC_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__CRSSparsity) >>= wrapReturn++foreign import ccall unsafe "CasADi__horzcat_TIC_TIC_TIC" c_CasADi__horzcat_TIC_TIC_TIC+ :: Ptr (CppVec (Ptr CRSSparsity')) -> IO (Ptr CRSSparsity')+horzcat'''+ :: Vector CRSSparsity -> IO CRSSparsity+horzcat''' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__horzcat_TIC_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__CRSSparsity) >>= wrapReturn++foreign import ccall unsafe "CasADi__blkdiag_TIC_TIC_TIC" c_CasADi__blkdiag_TIC_TIC_TIC+ :: Ptr (CppVec (Ptr CRSSparsity')) -> IO (Ptr CRSSparsity')+blkdiag'''+ :: Vector CRSSparsity -> IO CRSSparsity+blkdiag''' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__blkdiag_TIC_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__CRSSparsity) >>= wrapReturn++foreign import ccall unsafe "CasADi__sp_compress" c_CasADi__sp_compress+ :: Ptr CRSSparsity' -> IO (Ptr (CppVec CInt))+{-|+>> std::vector< int > CasADi::sp_compress(const CRSSparsity &a)+>------------------------------------------------------------------------+>+>Represent a sparsity pattern as an array of integers, the most compact way+>of representing a sparsity pattern The format: The first two entries are the+>number of rows (nrow) and columns (ncol) The next nrow+1 entries are the row+>offsets (rowind). Note that the last element rowind[nrow] gives the number+>of nonzeros The last rowind[nrow] entries are the column indices.+>+>Compress a sparsity pattern+>+>> CRSSparsity CasADi::sp_compress(const std::vector< int > &v)+>------------------------------------------------------------------------+>+>Decompress a sparsity pattern.+>+>> CRSSparsity CasADi::sp_compress(const int *v)+>------------------------------------------------------------------------+>+>Decompress a sparsity pattern (array version)+-}+sp_compress+ :: CRSSparsity -> IO (Vector Int)+sp_compress x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__sp_compress x0' >>= (newForeignPtr c_delete_std__vector_int_) >>= wrapReturn++foreign import ccall unsafe "CasADi__sp_compress_TIC" c_CasADi__sp_compress_TIC+ :: Ptr (CppVec CInt) -> IO (Ptr CRSSparsity')+sp_compress'+ :: Vector Int -> IO CRSSparsity+sp_compress' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__sp_compress_TIC x0' >>= (newForeignPtr c_delete_CasADi__CRSSparsity) >>= wrapReturn++foreign import ccall unsafe "CasADi__rank" c_CasADi__rank+ :: Ptr CRSSparsity' -> IO CInt+{-|+>Obtain the structural rank of a sparsity-pattern.+-}+rank+ :: CRSSparsity -> IO Int+rank x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__rank x0' >>= wrapReturn++foreign import ccall unsafe "CasADi__isSingular" c_CasADi__isSingular+ :: Ptr CRSSparsity' -> IO (Ptr CppBool')+{-|+>Check whether the sparsity-pattern inidcates structural singularity.+-}+isSingular+ :: CRSSparsity -> IO Bool+isSingular x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__isSingular x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++foreign import ccall unsafe "CasADi__ssym" c_CasADi__ssym+ :: Ptr StdString' -> CInt -> CInt -> IO (Ptr SXMatrix')+{-|+>> SXMatrix CasADi::ssym(const std::string &name, int n=1, int m=1)+>------------------------------------------------------------------------+>+>Construct symbolic arrays and variables using CasADi's SX expression graph+>representation The "ssym" function is intended to work in a similar way as+>"sym" used in the Symbolic Toolbox for Matlab but instead creating an+>SXMatrix object. The SX expression graph has much less overhead, but is also+>more restricted than the alternative MX expression graph.+>+>Construct symbolic arrays and variables using CasADi's more restricted, but+>more efficient SX expression graphCreate an n-by-m matrix with symbolic+>variables+>+>> SXMatrix CasADi::ssym(const std::string &name, const std::pair< int, int > &nm)+>------------------------------------------------------------------------+>+>Create an n-by-m matrix with symbolic variables.+>+>> SXMatrix CasADi::ssym(const std::string &name, const CRSSparsity &sp)+>------------------------------------------------------------------------+>+>Create an matrix with symbolic variables, given a sparsity pattern.+>+>> std::vector< SXMatrix > CasADi::ssym(const std::string &name, const CRSSparsity &sp, int p)+>------------------------------------------------------------------------+>+>Create a vector of length p with with matrices with symbolic variables of+>given sparsity.+>+>> std::vector< std::vector< SXMatrix > > CasADi::ssym(const std::string &name, const CRSSparsity &sp, int p, int r)+>------------------------------------------------------------------------+>+>Create a vector of length r of vectors of length p with matrices with+>symbolic variables with given sparsity.+>+>> std::vector< SXMatrix > CasADi::ssym(const std::string &name, int n, int m, int p)+>------------------------------------------------------------------------+>+>Create a vector of length p with n-by-m matrices with symbolic variables.+>+>> std::vector< std::vector< SXMatrix > > CasADi::ssym(const std::string &name, int n, int m, int p, int r)+>------------------------------------------------------------------------+>+>Create a vector of length r of vectors of length p with n-by-m matrices with+>symbolic variables.+>+>> SXMatrix CasADi::ssym(const Matrix< double > &x)+>------------------------------------------------------------------------+>+>Create a symbolic matrix out of a numeric one.+-}+ssym+ :: String -> Int -> Int -> IO SXMatrix+ssym x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__ssym x0' x1' x2' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++foreign import ccall unsafe "CasADi__ssym_TIC" c_CasADi__ssym_TIC+ :: Ptr StdString' -> CInt -> IO (Ptr SXMatrix')+ssym'+ :: String -> Int -> IO SXMatrix+ssym' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__ssym_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++foreign import ccall unsafe "CasADi__ssym_TIC_TIC" c_CasADi__ssym_TIC_TIC+ :: Ptr StdString' -> IO (Ptr SXMatrix')+ssym''+ :: String -> IO SXMatrix+ssym'' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__ssym_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++foreign import ccall unsafe "CasADi__ssym_TIC_TIC_TIC" c_CasADi__ssym_TIC_TIC_TIC+ :: Ptr StdString' -> Ptr CRSSparsity' -> CInt -> IO (Ptr (CppVec (Ptr SXMatrix')))+ssym'''+ :: String -> CRSSparsity -> Int -> IO (Vector SXMatrix)+ssym''' x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__ssym_TIC_TIC_TIC x0' x1' x2' >>= (newForeignPtr c_delete_std__vector_CasADi__Matrix_CasADi__SX__) >>= wrapReturn++foreign import ccall unsafe "CasADi__ssym_TIC_TIC_TIC_TIC" c_CasADi__ssym_TIC_TIC_TIC_TIC+ :: Ptr StdString' -> CInt -> CInt -> CInt -> IO (Ptr (CppVec (Ptr SXMatrix')))+ssym''''+ :: String -> Int -> Int -> Int -> IO (Vector SXMatrix)+ssym'''' x0 x1 x2 x3 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ withMarshal x3 $ \x3' ->+ c_CasADi__ssym_TIC_TIC_TIC_TIC x0' x1' x2' x3' >>= (newForeignPtr c_delete_std__vector_CasADi__Matrix_CasADi__SX__) >>= wrapReturn++foreign import ccall unsafe "CasADi__ssym_TIC_TIC_TIC_TIC_TIC" c_CasADi__ssym_TIC_TIC_TIC_TIC_TIC+ :: Ptr StdString' -> Ptr CRSSparsity' -> CInt -> CInt -> IO (Ptr (CppVecVec (Ptr SXMatrix')))+ssym'''''+ :: String -> CRSSparsity -> Int -> Int -> IO (Vector (Vector SXMatrix))+ssym''''' x0 x1 x2 x3 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ withMarshal x3 $ \x3' ->+ c_CasADi__ssym_TIC_TIC_TIC_TIC_TIC x0' x1' x2' x3' >>= (newForeignPtr c_delete_std__vector_std__vector_CasADi__Matrix_CasADi__SX___) >>= wrapReturn++foreign import ccall unsafe "CasADi__ssym_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__ssym_TIC_TIC_TIC_TIC_TIC_TIC+ :: Ptr StdString' -> CInt -> CInt -> CInt -> CInt -> IO (Ptr (CppVecVec (Ptr SXMatrix')))+ssym''''''+ :: String -> Int -> Int -> Int -> Int -> IO (Vector (Vector SXMatrix))+ssym'''''' x0 x1 x2 x3 x4 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ withMarshal x3 $ \x3' ->+ withMarshal x4 $ \x4' ->+ c_CasADi__ssym_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' x3' x4' >>= (newForeignPtr c_delete_std__vector_std__vector_CasADi__Matrix_CasADi__SX___) >>= wrapReturn++foreign import ccall unsafe "CasADi__ssym_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__ssym_TIC_TIC_TIC_TIC_TIC_TIC_TIC+ :: Ptr StdString' -> Ptr CRSSparsity' -> IO (Ptr SXMatrix')+ssym'''''''+ :: String -> CRSSparsity -> IO SXMatrix+ssym''''''' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__ssym_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++foreign import ccall unsafe "CasADi__ssym_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__ssym_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC+ :: Ptr DMatrix' -> IO (Ptr SXMatrix')+ssym''''''''+ :: DMatrix -> IO SXMatrix+ssym'''''''' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__ssym_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++foreign import ccall unsafe "CasADi__expand" c_CasADi__expand+ :: Ptr SXMatrix' -> Ptr SXMatrix' -> Ptr SXMatrix' -> IO ()+{-|+>Expand the expression as a weighted sum (with constant weights)+-}+expand+ :: SXMatrix -> SXMatrix -> SXMatrix -> IO ()+expand x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__expand x0' x1' x2' >>= wrapReturn++foreign import ccall unsafe "CasADi__simplify" c_CasADi__simplify+ :: Ptr SX' -> IO ()+{-|+>> void CasADi::simplify(MX &ex)+>+>> void CasADi::simplify(SXMatrix &ex)+>------------------------------------------------------------------------+>+>Simplify an expression.+>+>> void CasADi::simplify(SX &ex)+>------------------------------------------------------------------------+>+>Simplify the expression: formulates the expression as and eliminates terms.+-}+simplify+ :: SX -> IO ()+simplify x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__simplify x0' >>= wrapReturn++foreign import ccall unsafe "CasADi__pw_const" c_CasADi__pw_const+ :: Ptr SXMatrix' -> Ptr SXMatrix' -> Ptr SXMatrix' -> IO (Ptr SXMatrix')+{-|+>Create a piecewise constant function Create a piecewise constant function+>with n=val.size() intervals.+>+>Inputs:+>+>Parameters:+>-----------+>+>t: a scalar variable (e.g. time)+>+>tval: vector with the discrete values of t at the interval transitions+>(length n-1)+>+>val: vector with the value of the function for each interval (length n)+-}+pw_const+ :: SXMatrix -> SXMatrix -> SXMatrix -> IO SXMatrix+pw_const x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__pw_const x0' x1' x2' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++foreign import ccall unsafe "CasADi__pw_lin" c_CasADi__pw_lin+ :: Ptr SX' -> Ptr SXMatrix' -> Ptr SXMatrix' -> IO (Ptr SXMatrix')+{-|+>t a scalar variable (e.g. time)+>+>Create a piecewise linear function Create a piecewise linear function:+>+>Inputs: tval vector with the the discrete values of t (monotonically+>increasing) val vector with the corresponding function values (same length+>as tval)+-}+pw_lin+ :: SX -> SXMatrix -> SXMatrix -> IO SXMatrix+pw_lin x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__pw_lin x0' x1' x2' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++foreign import ccall unsafe "CasADi__if_else" c_CasADi__if_else+ :: Ptr SXMatrix' -> Ptr SXMatrix' -> Ptr SXMatrix' -> IO (Ptr SXMatrix')+{-|+>> MX CasADi::if_else(const MX &cond, const MX &if_true, const MX &if_false)+>------------------------------------------------------------------------+>+>Branching on MX nodes Ternary operator, "cond ? if_true : if_false".+-}+if_else+ :: SXMatrix -> SXMatrix -> SXMatrix -> IO SXMatrix+if_else x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__if_else x0' x1' x2' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++foreign import ccall unsafe "CasADi__heaviside" c_CasADi__heaviside+ :: Ptr SXMatrix' -> IO (Ptr SXMatrix')+{-|+>Heaviside function.+>+>\\[ \\begin{cases} H(x) = 0 & x<0 \\\\ H(x) = 1/2 & x=0 \\\\+>H(x) = 1 & x>0 \\\\ \\end{cases} \\]+-}+heaviside+ :: SXMatrix -> IO SXMatrix+heaviside x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__heaviside x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++foreign import ccall unsafe "CasADi__rectangle" c_CasADi__rectangle+ :: Ptr SXMatrix' -> IO (Ptr SXMatrix')+{-|+>rectangle function+>+>\\[ \\begin{cases} \\Pi(x) = 1 & |x| < 1/2 \\\\ \\Pi(x) = 1/2 &+>|x| = 1/2 \\\\ \\Pi(x) = 0 & |x| > 1/2 \\\\ \\end{cases} \\]+>+>Also called: gate function, block function, band function, pulse function,+>window function+-}+rectangle+ :: SXMatrix -> IO SXMatrix+rectangle x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__rectangle x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++foreign import ccall unsafe "CasADi__triangle" c_CasADi__triangle+ :: Ptr SXMatrix' -> IO (Ptr SXMatrix')+{-|+>triangle function+>+>\\[ \\begin{cases} \\Lambda(x) = 0 & |x| >= 1 \\\\ \\Lambda(x) =+>1-|x| & |x| < 1 \\end{cases} \\]+-}+triangle+ :: SXMatrix -> IO SXMatrix+triangle x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__triangle x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++foreign import ccall unsafe "CasADi__ramp" c_CasADi__ramp+ :: Ptr SXMatrix' -> IO (Ptr SXMatrix')+{-|+>ramp function+>+>\\[ \\begin{cases} R(x) = 0 & x <= 1 \\\\ R(x) = x & x > 1 \\\\+>\\end{cases} \\]+>+>Also called: slope function+-}+ramp+ :: SXMatrix -> IO SXMatrix+ramp x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__ramp x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++foreign import ccall unsafe "CasADi__gauss_quadrature" c_CasADi__gauss_quadrature+ :: Ptr SXMatrix' -> Ptr SXMatrix' -> Ptr SXMatrix' -> Ptr SXMatrix' -> CInt -> Ptr SXMatrix' -> IO (Ptr SXMatrix')+{-|+>Integrate f from a to b using Gaussian quadrature with n points.+-}+gauss_quadrature+ :: SXMatrix -> SXMatrix -> SXMatrix -> SXMatrix -> Int -> SXMatrix -> IO SXMatrix+gauss_quadrature x0 x1 x2 x3 x4 x5 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ withMarshal x3 $ \x3' ->+ withMarshal x4 $ \x4' ->+ withMarshal x5 $ \x5' ->+ c_CasADi__gauss_quadrature x0' x1' x2' x3' x4' x5' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++foreign import ccall unsafe "CasADi__gauss_quadrature_TIC" c_CasADi__gauss_quadrature_TIC+ :: Ptr SXMatrix' -> Ptr SXMatrix' -> Ptr SXMatrix' -> Ptr SXMatrix' -> CInt -> IO (Ptr SXMatrix')+gauss_quadrature'+ :: SXMatrix -> SXMatrix -> SXMatrix -> SXMatrix -> Int -> IO SXMatrix+gauss_quadrature' x0 x1 x2 x3 x4 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ withMarshal x3 $ \x3' ->+ withMarshal x4 $ \x4' ->+ c_CasADi__gauss_quadrature_TIC x0' x1' x2' x3' x4' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++foreign import ccall unsafe "CasADi__gauss_quadrature_TIC_TIC" c_CasADi__gauss_quadrature_TIC_TIC+ :: Ptr SXMatrix' -> Ptr SXMatrix' -> Ptr SXMatrix' -> Ptr SXMatrix' -> IO (Ptr SXMatrix')+gauss_quadrature''+ :: SXMatrix -> SXMatrix -> SXMatrix -> SXMatrix -> IO SXMatrix+gauss_quadrature'' x0 x1 x2 x3 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ withMarshal x3 $ \x3' ->+ c_CasADi__gauss_quadrature_TIC_TIC x0' x1' x2' x3' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++foreign import ccall unsafe "CasADi__simplify_TIC" c_CasADi__simplify_TIC+ :: Ptr SXMatrix' -> IO ()+simplify'+ :: SXMatrix -> IO ()+simplify' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__simplify_TIC x0' >>= wrapReturn++foreign import ccall unsafe "CasADi__compress" c_CasADi__compress+ :: Ptr SXMatrix' -> CInt -> IO ()+{-|+>Remove identical calculations.+-}+compress+ :: SXMatrix -> Int -> IO ()+compress x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__compress x0' x1' >>= wrapReturn++foreign import ccall unsafe "CasADi__compress_TIC" c_CasADi__compress_TIC+ :: Ptr SXMatrix' -> IO ()+compress'+ :: SXMatrix -> IO ()+compress' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__compress_TIC x0' >>= wrapReturn++foreign import ccall unsafe "CasADi__substitute" c_CasADi__substitute+ :: Ptr SXMatrix' -> Ptr SXMatrix' -> Ptr SXMatrix' -> IO (Ptr SXMatrix')+{-|+>> MX CasADi::substitute(const MX &ex, const MX &v, const MX &vdef)+>+>> SXMatrix CasADi::substitute(const SXMatrix &ex, const SXMatrix &v, const SXMatrix &vdef)+>------------------------------------------------------------------------+>+>Substitute variable v with expression vdef in an expression ex.+>+>> std::vector< MX > CasADi::substitute(const std::vector< MX > &ex, const std::vector< MX > &v, const std::vector< MX > &vdef)+>+>> std::vector< SXMatrix > CasADi::substitute(const std::vector< SXMatrix > &ex, const std::vector< SXMatrix > &v, const std::vector< SXMatrix > &vdef)+>------------------------------------------------------------------------+>+>Substitute variable var with expression expr in multiple expressions.+-}+substitute+ :: SXMatrix -> SXMatrix -> SXMatrix -> IO SXMatrix+substitute x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__substitute x0' x1' x2' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++foreign import ccall unsafe "CasADi__substitute_TIC" c_CasADi__substitute_TIC+ :: Ptr (CppVec (Ptr SXMatrix')) -> Ptr (CppVec (Ptr SXMatrix')) -> Ptr (CppVec (Ptr SXMatrix')) -> IO (Ptr (CppVec (Ptr SXMatrix')))+substitute'+ :: Vector SXMatrix -> Vector SXMatrix -> Vector SXMatrix -> IO (Vector SXMatrix)+substitute' x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__substitute_TIC x0' x1' x2' >>= (newForeignPtr c_delete_std__vector_CasADi__Matrix_CasADi__SX__) >>= wrapReturn++foreign import ccall unsafe "CasADi__substituteInPlace" c_CasADi__substituteInPlace+ :: Ptr SXMatrix' -> Ptr SXMatrix' -> Ptr CppBool' -> IO ()+{-|+>> void CasADi::substituteInPlace(const std::vector< MX > &v, std::vector< MX > &vdef, bool reverse=false)+>------------------------------------------------------------------------+>+>Inplace substitution Substitute variables v out of the expressions vdef+>sequentially.+>+>> void CasADi::substituteInPlace(const std::vector< MX > &v, std::vector< MX > &vdef, std::vector< MX > &ex, bool reverse=false)+>------------------------------------------------------------------------+>+>Inplace substitution with piggyback expressions Substitute variables v out+>of the expressions vdef sequentially, as well as out of a number of other+>expressions piggyback.+>+>> void CasADi::substituteInPlace(const SXMatrix &v, SXMatrix &vdef, bool reverse=false)+>------------------------------------------------------------------------+>+>Substitute variable var out of or into an expression expr.+>+>> void CasADi::substituteInPlace(const SXMatrix &v, SXMatrix &vdef, std::vector< SXMatrix > &ex, bool reverse=false)+>------------------------------------------------------------------------+>+>Substitute variable var out of or into an expression expr, with an arbitrary+>number of other expressions piggyback.+>+>> void CasADi::substituteInPlace(const std::vector< SXMatrix > &v, std::vector< SXMatrix > &vdef, std::vector< SXMatrix > &ex, bool reverse=false)+>------------------------------------------------------------------------+>+>Substitute variable var out of or into an expression expr, with an arbitrary+>number of other expressions piggyback (vector version)+-}+substituteInPlace+ :: SXMatrix -> SXMatrix -> Bool -> IO ()+substituteInPlace x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__substituteInPlace x0' x1' x2' >>= wrapReturn++foreign import ccall unsafe "CasADi__substituteInPlace_TIC" c_CasADi__substituteInPlace_TIC+ :: Ptr SXMatrix' -> Ptr SXMatrix' -> IO ()+substituteInPlace'+ :: SXMatrix -> SXMatrix -> IO ()+substituteInPlace' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__substituteInPlace_TIC x0' x1' >>= wrapReturn++foreign import ccall unsafe "CasADi__substituteInPlace_TIC_TIC" c_CasADi__substituteInPlace_TIC_TIC+ :: Ptr SXMatrix' -> Ptr SXMatrix' -> Ptr (CppVec (Ptr SXMatrix')) -> Ptr CppBool' -> IO ()+substituteInPlace''+ :: SXMatrix -> SXMatrix -> Vector SXMatrix -> Bool -> IO ()+substituteInPlace'' x0 x1 x2 x3 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ withMarshal x3 $ \x3' ->+ c_CasADi__substituteInPlace_TIC_TIC x0' x1' x2' x3' >>= wrapReturn++foreign import ccall unsafe "CasADi__substituteInPlace_TIC_TIC_TIC" c_CasADi__substituteInPlace_TIC_TIC_TIC+ :: Ptr SXMatrix' -> Ptr SXMatrix' -> Ptr (CppVec (Ptr SXMatrix')) -> IO ()+substituteInPlace'''+ :: SXMatrix -> SXMatrix -> Vector SXMatrix -> IO ()+substituteInPlace''' x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__substituteInPlace_TIC_TIC_TIC x0' x1' x2' >>= wrapReturn++foreign import ccall unsafe "CasADi__substituteInPlace_TIC_TIC_TIC_TIC" c_CasADi__substituteInPlace_TIC_TIC_TIC_TIC+ :: Ptr (CppVec (Ptr SXMatrix')) -> Ptr (CppVec (Ptr SXMatrix')) -> Ptr (CppVec (Ptr SXMatrix')) -> Ptr CppBool' -> IO ()+substituteInPlace''''+ :: Vector SXMatrix -> Vector SXMatrix -> Vector SXMatrix -> Bool -> IO ()+substituteInPlace'''' x0 x1 x2 x3 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ withMarshal x3 $ \x3' ->+ c_CasADi__substituteInPlace_TIC_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn++foreign import ccall unsafe "CasADi__substituteInPlace_TIC_TIC_TIC_TIC_TIC" c_CasADi__substituteInPlace_TIC_TIC_TIC_TIC_TIC+ :: Ptr (CppVec (Ptr SXMatrix')) -> Ptr (CppVec (Ptr SXMatrix')) -> Ptr (CppVec (Ptr SXMatrix')) -> IO ()+substituteInPlace'''''+ :: Vector SXMatrix -> Vector SXMatrix -> Vector SXMatrix -> IO ()+substituteInPlace''''' x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__substituteInPlace_TIC_TIC_TIC_TIC_TIC x0' x1' x2' >>= wrapReturn++foreign import ccall unsafe "CasADi__evalf" c_CasADi__evalf+ :: Ptr SXMatrix' -> IO (Ptr DMatrix')+{-|+>> Matrix< double > CasADi::evalf(const SXMatrix &ex, const SXMatrix &v, const Matrix< double > &vdef)+>------------------------------------------------------------------------+>+>Substitute variable v with value vdef in an expression ex, and evaluate+>numerically Note: this is not efficient. For critical parts (loops) of your+>code, always use SXFunction.+>+>See: numSample1D+>+>> Matrix< double > CasADi::evalf(const SXMatrix &ex)+>------------------------------------------------------------------------+>+>Evaluate an SX graph numerically Note: this is not efficient. For critical+>parts (loops) of your code, always use SXFunction.+-}+evalf+ :: SXMatrix -> IO DMatrix+evalf x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__evalf x0' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++foreign import ccall unsafe "CasADi__evalf_TIC" c_CasADi__evalf_TIC+ :: Ptr SXMatrix' -> Ptr SXMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')+evalf'+ :: SXMatrix -> SXMatrix -> DMatrix -> IO DMatrix+evalf' x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__evalf_TIC x0' x1' x2' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++foreign import ccall unsafe "CasADi__isRegular_TIC_TIC_TIC_TIC" c_CasADi__isRegular_TIC_TIC_TIC_TIC+ :: Ptr SX' -> IO (Ptr CppBool')+isRegular''''+ :: SX -> IO Bool+isRegular'''' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__isRegular_TIC_TIC_TIC_TIC x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++foreign import ccall unsafe "CasADi__isRegular_TIC_TIC_TIC_TIC_TIC" c_CasADi__isRegular_TIC_TIC_TIC_TIC_TIC+ :: Ptr SXMatrix' -> IO (Ptr CppBool')+isRegular'''''+ :: SXMatrix -> IO Bool+isRegular''''' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__isRegular_TIC_TIC_TIC_TIC_TIC x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++foreign import ccall unsafe "CasADi__spy" c_CasADi__spy+ :: Ptr SXMatrix' -> IO (Ptr SXMatrix')+{-|+>Get the sparsity pattern of a matrix.+-}+spy+ :: SXMatrix -> IO SXMatrix+spy x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__spy x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++foreign import ccall unsafe "CasADi__dependsOn" c_CasADi__dependsOn+ :: Ptr SXMatrix' -> Ptr SXMatrix' -> IO (Ptr CppBool')+{-|+>Check dependency: very inefficient algorithm.+-}+dependsOn+ :: SXMatrix -> SXMatrix -> IO Bool+dependsOn x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__dependsOn x0' x1' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++foreign import ccall unsafe "CasADi__getSymbols" c_CasADi__getSymbols+ :: Ptr SXMatrix' -> IO (Ptr (CppVec (Ptr SX')))+{-|+>> std::vector< MX > CasADi::getSymbols(const MX &e)+>+>> std::vector< MX > CasADi::getSymbols(const std::vector< MX > &e)+>------------------------------------------------------------------------+>+>Get all symbols contained in the supplied expression Get all symbols on+>which the supplied expression depends.+>+>See: MXFunction::getFree()+>+>> std::vector< SX > CasADi::getSymbols(const SXMatrix &e)+>------------------------------------------------------------------------+>+>Get all symbols contained in the supplied expression Get all symbols on+>which the supplied expression depends.+>+>See: SXFunction::getFree()+-}+getSymbols+ :: SXMatrix -> IO (Vector SX)+getSymbols x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__getSymbols x0' >>= (newForeignPtr c_delete_std__vector_CasADi__SX_) >>= wrapReturn++foreign import ccall unsafe "CasADi__isSmooth" c_CasADi__isSmooth+ :: Ptr SXMatrix' -> IO (Ptr CppBool')+{-|+>check if smooth+-}+isSmooth+ :: SXMatrix -> IO Bool+isSmooth x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__isSmooth x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++foreign import ccall unsafe "CasADi__isSymbolic" c_CasADi__isSymbolic+ :: Ptr SXMatrix' -> IO (Ptr CppBool')+{-|+>> bool CasADi::isSymbolic(const MX &ex)+>------------------------------------------------------------------------+>+>check if symbolic+>+>> bool CasADi::isSymbolic(const SXMatrix &ex)+>------------------------------------------------------------------------+>+>check if symbolic (Dense)+>+>Sparse matrices invariable return false+-}+isSymbolic+ :: SXMatrix -> IO Bool+isSymbolic x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__isSymbolic x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++foreign import ccall unsafe "CasADi__isSymbolicSparse" c_CasADi__isSymbolicSparse+ :: Ptr SXMatrix' -> IO (Ptr CppBool')+{-|+>> bool CasADi::isSymbolicSparse(const MX &ex)+>------------------------------------------------------------------------+>+>check if all nonzeros are symbolic (this function is currently identical to+>isSymbolic)+>+>> bool CasADi::isSymbolicSparse(const SXMatrix &ex)+>------------------------------------------------------------------------+>+>check if symbolic+>+>Sparse matrices can return true if all non-zero elements are symbolic+-}+isSymbolicSparse+ :: SXMatrix -> IO Bool+isSymbolicSparse x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__isSymbolicSparse x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++foreign import ccall unsafe "CasADi__jacobian" c_CasADi__jacobian+ :: Ptr SXMatrix' -> Ptr SXMatrix' -> IO (Ptr SXMatrix')+{-|+>> MX CasADi::jacobian(const MX &ex, const MX &arg)+>------------------------------------------------------------------------+>+>Calculate jacobian via source code transformation.+>+>Uses CasADi::MXFunction::jac+>+>> SXMatrix CasADi::jacobian(const SXMatrix &ex, const SXMatrix &arg)+>------------------------------------------------------------------------+>+>Calculate jacobian via source code transformation.+>+>Uses CasADi::SXFunction::jac+-}+jacobian+ :: SXMatrix -> SXMatrix -> IO SXMatrix+jacobian x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__jacobian x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++foreign import ccall unsafe "CasADi__gradient" c_CasADi__gradient+ :: Ptr SXMatrix' -> Ptr SXMatrix' -> IO (Ptr SXMatrix')+{-|+>> MX CasADi::gradient(const MX &ex, const MX &arg)+>------------------------------------------------------------------------+>+>Calculate jacobian via source code transformation.+>+>Uses CasADi::MXFunction::jac+>+>> SXMatrix CasADi::gradient(const SXMatrix &ex, const SXMatrix &arg)+>------------------------------------------------------------------------+>+>Calculate jacobian via source code transformation.+>+>Uses CasADi::SXFunction::jac+-}+gradient+ :: SXMatrix -> SXMatrix -> IO SXMatrix+gradient x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__gradient x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++foreign import ccall unsafe "CasADi__tangent" c_CasADi__tangent+ :: Ptr SXMatrix' -> Ptr SXMatrix' -> IO (Ptr SXMatrix')+{-|+>> MX CasADi::tangent(const MX &ex, const MX &arg)+>------------------------------------------------------------------------+>+>Calculate jacobian via source code transformation.+>+>Uses CasADi::MXFunction::jac+>+>> SXMatrix CasADi::tangent(const SXMatrix &ex, const SXMatrix &arg)+>------------------------------------------------------------------------+>+>Calculate jacobian via source code transformation.+>+>Uses CasADi::SXFunction::jac+-}+tangent+ :: SXMatrix -> SXMatrix -> IO SXMatrix+tangent x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__tangent x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++foreign import ccall unsafe "CasADi__hessian" c_CasADi__hessian+ :: Ptr SXMatrix' -> Ptr SXMatrix' -> IO (Ptr SXMatrix')+{-|+>Calculate jacobian via source code transformation.+>+>Uses CasADi::SXFunction::jac+-}+hessian+ :: SXMatrix -> SXMatrix -> IO SXMatrix+hessian x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__hessian x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++foreign import ccall unsafe "CasADi__hessian_TIC" c_CasADi__hessian_TIC+ :: Ptr SXMatrix' -> Ptr SXMatrix' -> Ptr SXMatrix' -> Ptr SXMatrix' -> IO ()+hessian'+ :: SXMatrix -> SXMatrix -> SXMatrix -> SXMatrix -> IO ()+hessian' x0 x1 x2 x3 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ withMarshal x3 $ \x3' ->+ c_CasADi__hessian_TIC x0' x1' x2' x3' >>= wrapReturn++foreign import ccall unsafe "CasADi__jacobianTimesVector" c_CasADi__jacobianTimesVector+ :: Ptr SXMatrix' -> Ptr SXMatrix' -> Ptr SXMatrix' -> Ptr CppBool' -> IO (Ptr SXMatrix')+{-|+>Calculate the Jacobian and multiply by a vector from the left This is+>equivalent to mul(jacobian(ex,arg),v) or mul(jacobian(ex,arg).T,v) for+>transpose_jacobian set to false and true respectively. If contrast to these+>expressions, it will use directional derivatives which is typically (but not+>necessarily) more efficient if the complete Jacobian is not needed and v has+>few columns.+-}+jacobianTimesVector+ :: SXMatrix -> SXMatrix -> SXMatrix -> Bool -> IO SXMatrix+jacobianTimesVector x0 x1 x2 x3 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ withMarshal x3 $ \x3' ->+ c_CasADi__jacobianTimesVector x0' x1' x2' x3' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++foreign import ccall unsafe "CasADi__jacobianTimesVector_TIC" c_CasADi__jacobianTimesVector_TIC+ :: Ptr SXMatrix' -> Ptr SXMatrix' -> Ptr SXMatrix' -> IO (Ptr SXMatrix')+jacobianTimesVector'+ :: SXMatrix -> SXMatrix -> SXMatrix -> IO SXMatrix+jacobianTimesVector' x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__jacobianTimesVector_TIC x0' x1' x2' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++foreign import ccall unsafe "CasADi__getValue" c_CasADi__getValue+ :: Ptr SXMatrix' -> CInt -> CInt -> IO CDouble+{-|+>> double CasADi::getValue(const SXMatrix &ex, int i=0, int j=0)+>------------------------------------------------------------------------+>+>Obtain the values of a constant expression.+-}+getValue+ :: SXMatrix -> Int -> Int -> IO Double+getValue x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__getValue x0' x1' x2' >>= wrapReturn++foreign import ccall unsafe "CasADi__getValue_TIC" c_CasADi__getValue_TIC+ :: Ptr SXMatrix' -> CInt -> IO CDouble+getValue'+ :: SXMatrix -> Int -> IO Double+getValue' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__getValue_TIC x0' x1' >>= wrapReturn++foreign import ccall unsafe "CasADi__getValue_TIC_TIC" c_CasADi__getValue_TIC_TIC+ :: Ptr SXMatrix' -> IO CDouble+getValue''+ :: SXMatrix -> IO Double+getValue'' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__getValue_TIC_TIC x0' >>= wrapReturn++foreign import ccall unsafe "CasADi__getIntValue" c_CasADi__getIntValue+ :: Ptr SXMatrix' -> CInt -> CInt -> IO CInt+getIntValue+ :: SXMatrix -> Int -> Int -> IO Int+getIntValue x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__getIntValue x0' x1' x2' >>= wrapReturn++foreign import ccall unsafe "CasADi__getIntValue_TIC" c_CasADi__getIntValue_TIC+ :: Ptr SXMatrix' -> CInt -> IO CInt+getIntValue'+ :: SXMatrix -> Int -> IO Int+getIntValue' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__getIntValue_TIC x0' x1' >>= wrapReturn++foreign import ccall unsafe "CasADi__getIntValue_TIC_TIC" c_CasADi__getIntValue_TIC_TIC+ :: Ptr SXMatrix' -> IO CInt+getIntValue''+ :: SXMatrix -> IO Int+getIntValue'' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__getIntValue_TIC_TIC x0' >>= wrapReturn++foreign import ccall unsafe "CasADi__fill" c_CasADi__fill+ :: Ptr SXMatrix' -> Ptr SX' -> IO ()+{-|+>Fill the matrix with the value val, make empty sparse if zero.+-}+fill+ :: SXMatrix -> SX -> IO ()+fill x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__fill x0' x1' >>= wrapReturn++foreign import ccall unsafe "CasADi__taylor" c_CasADi__taylor+ :: Ptr SXMatrix' -> Ptr SXMatrix' -> Ptr SXMatrix' -> CInt -> IO (Ptr SXMatrix')+{-|+>univariate taylor series expansion+>+>Calculate the taylor expansion of expression 'ex' up to order 'order' with+>repsect to variable 'x' around the point 'a'+>+>$(x)=f(a)+f'(a)(x-a)+f''(a)\\frac{(x-a)^2}{2!}+f'''(a)\\frac{(x-a)^3}{3!}+\\ldots$+>+>Example usage:>> x+-}+taylor+ :: SXMatrix -> SXMatrix -> SXMatrix -> Int -> IO SXMatrix+taylor x0 x1 x2 x3 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ withMarshal x3 $ \x3' ->+ c_CasADi__taylor x0' x1' x2' x3' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++foreign import ccall unsafe "CasADi__taylor_TIC" c_CasADi__taylor_TIC+ :: Ptr SXMatrix' -> Ptr SXMatrix' -> Ptr SXMatrix' -> IO (Ptr SXMatrix')+taylor'+ :: SXMatrix -> SXMatrix -> SXMatrix -> IO SXMatrix+taylor' x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__taylor_TIC x0' x1' x2' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++foreign import ccall unsafe "CasADi__taylor_TIC_TIC" c_CasADi__taylor_TIC_TIC+ :: Ptr SXMatrix' -> Ptr SXMatrix' -> IO (Ptr SXMatrix')+taylor''+ :: SXMatrix -> SXMatrix -> IO SXMatrix+taylor'' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__taylor_TIC_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++foreign import ccall unsafe "CasADi__mtaylor" c_CasADi__mtaylor+ :: Ptr SXMatrix' -> Ptr SXMatrix' -> Ptr SXMatrix' -> CInt -> IO (Ptr SXMatrix')+{-|+>> SXMatrix CasADi::mtaylor(const SXMatrix &ex, const SXMatrix &x, const SXMatrix &a, int order=1)+>------------------------------------------------------------------------+>+>multivariate taylor series expansion+>+>Do taylor expansions until the aggregated order of a term is equal to+>'order'. The aggregated order of $x^n y^m$ equals $n+m$.+>+>> SXMatrix CasADi::mtaylor(const SXMatrix &ex, const SXMatrix &x, const SXMatrix &a, int order, const std::vector< int > &order_contributions)+>------------------------------------------------------------------------+>+>multivariate taylor series expansion+>+>Do taylor expansions until the aggregated order of a term is equal to+>'order'. The aggregated order of $x^n y^m$ equals $n+m$.+>+>The argument order_contributions can denote how match each variable+>contributes to the aggregated order. If x=[x,y] and+>order_contributions=[1,2], then the aggregated order of $x^n y^m$ equals+>$1n+2m$.+>+>Example usage+>+>$ \\sin(b+a)+\\cos(b+a)(x-a)+\\cos(b+a)(y-b) $ $ y+x-(x^3+3y x^2+3 y^2+>x+y^3)/6 $ $ (-3 x^2 y-x^3)/6+y+x $+-}+mtaylor+ :: SXMatrix -> SXMatrix -> SXMatrix -> Int -> IO SXMatrix+mtaylor x0 x1 x2 x3 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ withMarshal x3 $ \x3' ->+ c_CasADi__mtaylor x0' x1' x2' x3' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++foreign import ccall unsafe "CasADi__mtaylor_TIC" c_CasADi__mtaylor_TIC+ :: Ptr SXMatrix' -> Ptr SXMatrix' -> Ptr SXMatrix' -> IO (Ptr SXMatrix')+mtaylor'+ :: SXMatrix -> SXMatrix -> SXMatrix -> IO SXMatrix+mtaylor' x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__mtaylor_TIC x0' x1' x2' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++foreign import ccall unsafe "CasADi__mtaylor_TIC_TIC" c_CasADi__mtaylor_TIC_TIC+ :: Ptr SXMatrix' -> Ptr SXMatrix' -> Ptr SXMatrix' -> CInt -> Ptr (CppVec CInt) -> IO (Ptr SXMatrix')+mtaylor''+ :: SXMatrix -> SXMatrix -> SXMatrix -> Int -> Vector Int -> IO SXMatrix+mtaylor'' x0 x1 x2 x3 x4 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ withMarshal x3 $ \x3' ->+ withMarshal x4 $ \x4' ->+ c_CasADi__mtaylor_TIC_TIC x0' x1' x2' x3' x4' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++foreign import ccall unsafe "CasADi__countNodes" c_CasADi__countNodes+ :: Ptr SXMatrix' -> IO CInt+{-|+>> int CasADi::countNodes(const MX &A)+>------------------------------------------------------------------------+>+>Count number of nodes+>+>> int CasADi::countNodes(const SXMatrix &A)+>------------------------------------------------------------------------+>+>Count number of nodes.+-}+countNodes+ :: SXMatrix -> IO Int+countNodes x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__countNodes x0' >>= wrapReturn++foreign import ccall unsafe "CasADi__getOperatorRepresentation" c_CasADi__getOperatorRepresentation+ :: Ptr SX' -> Ptr (CppVec (Ptr StdString')) -> IO (Ptr StdString')+{-|+>> std::string CasADi::getOperatorRepresentation(const MX &x, const std::vector< std::string > &args)+>------------------------------------------------------------------------+>+>Get a string representation for a binary MX, using custom arguments.+>+>> std::string CasADi::getOperatorRepresentation(const SX &x, const std::vector< std::string > &args)+>------------------------------------------------------------------------+>+>Get a string representation for a binary SX, using custom arguments.+-}+getOperatorRepresentation+ :: SX -> Vector String -> IO String+getOperatorRepresentation x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal (CornerCase x1) $ \x1' ->+ c_CasADi__getOperatorRepresentation x0' x1' >>= (newForeignPtr c_delete_std__string) >>= wrapReturn++foreign import ccall unsafe "CasADi__getFree" c_CasADi__getFree+ :: Ptr SXMatrix' -> IO (Ptr SXMatrix')+{-|+>Get all the free variables in an expression.+-}+getFree+ :: SXMatrix -> IO SXMatrix+getFree x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__getFree x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++foreign import ccall unsafe "CasADi__extractShared" c_CasADi__extractShared+ :: Ptr (CppVec (Ptr SX')) -> Ptr (CppVec (Ptr SX')) -> Ptr (CppVec (Ptr SX')) -> Ptr StdString' -> Ptr StdString' -> IO ()+{-|+>Extract shared subexpressions from an set of expressions.+-}+extractShared+ :: Vector SX -> Vector SX -> Vector SX -> String -> String -> IO ()+extractShared x0 x1 x2 x3 x4 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ withMarshal x3 $ \x3' ->+ withMarshal x4 $ \x4' ->+ c_CasADi__extractShared x0' x1' x2' x3' x4' >>= wrapReturn++foreign import ccall unsafe "CasADi__extractShared_TIC" c_CasADi__extractShared_TIC+ :: Ptr (CppVec (Ptr SX')) -> Ptr (CppVec (Ptr SX')) -> Ptr (CppVec (Ptr SX')) -> Ptr StdString' -> IO ()+extractShared'+ :: Vector SX -> Vector SX -> Vector SX -> String -> IO ()+extractShared' x0 x1 x2 x3 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ withMarshal x3 $ \x3' ->+ c_CasADi__extractShared_TIC x0' x1' x2' x3' >>= wrapReturn++foreign import ccall unsafe "CasADi__extractShared_TIC_TIC" c_CasADi__extractShared_TIC_TIC+ :: Ptr (CppVec (Ptr SX')) -> Ptr (CppVec (Ptr SX')) -> Ptr (CppVec (Ptr SX')) -> IO ()+extractShared''+ :: Vector SX -> Vector SX -> Vector SX -> IO ()+extractShared'' x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__extractShared_TIC_TIC x0' x1' x2' >>= wrapReturn++foreign import ccall unsafe "CasADi__printCompact_TIC" c_CasADi__printCompact_TIC+ :: Ptr SXMatrix' -> IO ()+printCompact'+ :: SXMatrix -> IO ()+printCompact' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__printCompact_TIC x0' >>= wrapReturn++foreign import ccall unsafe "CasADi__poly_coeff" c_CasADi__poly_coeff+ :: Ptr SXMatrix' -> Ptr SXMatrix' -> IO (Ptr SXMatrix')+{-|+>extracts polynomial coefficients from an expression+>+>ex Scalar expression that represents a polynomial x Scalar symbol that th+>epolynomial is build up with+-}+poly_coeff+ :: SXMatrix -> SXMatrix -> IO SXMatrix+poly_coeff x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__poly_coeff x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++foreign import ccall unsafe "CasADi__poly_roots" c_CasADi__poly_roots+ :: Ptr SXMatrix' -> IO (Ptr SXMatrix')+{-|+>Attempts to find the roots of a polynomial.+>+>This will only work for polynomials up to order 3 It is assumed that the+>roots are real.+-}+poly_roots+ :: SXMatrix -> IO SXMatrix+poly_roots x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__poly_roots x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++foreign import ccall unsafe "CasADi__eig_symbolic" c_CasADi__eig_symbolic+ :: Ptr SXMatrix' -> IO (Ptr SXMatrix')+{-|+>Attempts to find the eigenvalues of a symbolic matrix This will only work+>for up to 3x3 matrices.+>+>Bring m in block diagonal form, calculating eigenvalues of each block+>seperately +-}+eig_symbolic+ :: SXMatrix -> IO SXMatrix+eig_symbolic x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__eig_symbolic x0' >>= (newForeignPtr c_delete_CasADi__Matrix_CasADi__SX_) >>= wrapReturn++foreign import ccall unsafe "CasADi__vertcat_TIC_TIC_TIC_TIC" c_CasADi__vertcat_TIC_TIC_TIC_TIC+ :: Ptr (CppVec (Ptr MX')) -> IO (Ptr MX')+vertcat''''+ :: Vector MX -> IO MX+vertcat'''' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__vertcat_TIC_TIC_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++foreign import ccall unsafe "CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC+ :: Ptr MX' -> Ptr (CppVec CInt) -> IO (Ptr (CppVec (Ptr MX')))+vertsplit'''''''''+ :: MX -> Vector Int -> IO (Vector MX)+vertsplit''''''''' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' >>= (newForeignPtr c_delete_std__vector_CasADi__MX_) >>= wrapReturn++foreign import ccall unsafe "CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC+ :: Ptr MX' -> CInt -> IO (Ptr (CppVec (Ptr MX')))+vertsplit''''''''''+ :: MX -> Int -> IO (Vector MX)+vertsplit'''''''''' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' >>= (newForeignPtr c_delete_std__vector_CasADi__MX_) >>= wrapReturn++foreign import ccall unsafe "CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC+ :: Ptr MX' -> IO (Ptr (CppVec (Ptr MX')))+vertsplit'''''''''''+ :: MX -> IO (Vector MX)+vertsplit''''''''''' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' >>= (newForeignPtr c_delete_std__vector_CasADi__MX_) >>= wrapReturn++foreign import ccall unsafe "CasADi__horzcat_TIC_TIC_TIC_TIC" c_CasADi__horzcat_TIC_TIC_TIC_TIC+ :: Ptr (CppVec (Ptr MX')) -> IO (Ptr MX')+horzcat''''+ :: Vector MX -> IO MX+horzcat'''' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__horzcat_TIC_TIC_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++foreign import ccall unsafe "CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC+ :: Ptr MX' -> Ptr (CppVec CInt) -> IO (Ptr (CppVec (Ptr MX')))+horzsplit'''''''''+ :: MX -> Vector Int -> IO (Vector MX)+horzsplit''''''''' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' >>= (newForeignPtr c_delete_std__vector_CasADi__MX_) >>= wrapReturn++foreign import ccall unsafe "CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC+ :: Ptr MX' -> CInt -> IO (Ptr (CppVec (Ptr MX')))+horzsplit''''''''''+ :: MX -> Int -> IO (Vector MX)+horzsplit'''''''''' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' >>= (newForeignPtr c_delete_std__vector_CasADi__MX_) >>= wrapReturn++foreign import ccall unsafe "CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC+ :: Ptr MX' -> IO (Ptr (CppVec (Ptr MX')))+horzsplit'''''''''''+ :: MX -> IO (Vector MX)+horzsplit''''''''''' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' >>= (newForeignPtr c_delete_std__vector_CasADi__MX_) >>= wrapReturn++foreign import ccall unsafe "CasADi__blockcat_TIC_TIC_TIC" c_CasADi__blockcat_TIC_TIC_TIC+ :: Ptr (CppVecVec (Ptr MX')) -> IO (Ptr MX')+blockcat'''+ :: Vector (Vector MX) -> IO MX+blockcat''' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__blockcat_TIC_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++foreign import ccall unsafe "CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC+ :: Ptr MX' -> Ptr (CppVec CInt) -> Ptr (CppVec CInt) -> IO (Ptr (CppVecVec (Ptr MX')))+blocksplit''''''''''''+ :: MX -> Vector Int -> Vector Int -> IO (Vector (Vector MX))+blocksplit'''''''''''' x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' >>= (newForeignPtr c_delete_std__vector_std__vector_CasADi__MX__) >>= wrapReturn++foreign import ccall unsafe "CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC+ :: Ptr MX' -> CInt -> CInt -> IO (Ptr (CppVecVec (Ptr MX')))+blocksplit'''''''''''''+ :: MX -> Int -> Int -> IO (Vector (Vector MX))+blocksplit''''''''''''' x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' >>= (newForeignPtr c_delete_std__vector_std__vector_CasADi__MX__) >>= wrapReturn++foreign import ccall unsafe "CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC+ :: Ptr MX' -> CInt -> IO (Ptr (CppVecVec (Ptr MX')))+blocksplit''''''''''''''+ :: MX -> Int -> IO (Vector (Vector MX))+blocksplit'''''''''''''' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' >>= (newForeignPtr c_delete_std__vector_std__vector_CasADi__MX__) >>= wrapReturn++foreign import ccall unsafe "CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC+ :: Ptr MX' -> IO (Ptr (CppVecVec (Ptr MX')))+blocksplit'''''''''''''''+ :: MX -> IO (Vector (Vector MX))+blocksplit''''''''''''''' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' >>= (newForeignPtr c_delete_std__vector_std__vector_CasADi__MX__) >>= wrapReturn++foreign import ccall unsafe "CasADi__veccat_TIC_TIC_TIC" c_CasADi__veccat_TIC_TIC_TIC+ :: Ptr (CppVec (Ptr MX')) -> IO (Ptr MX')+veccat'''+ :: Vector MX -> IO MX+veccat''' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__veccat_TIC_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++foreign import ccall unsafe "CasADi__flattencat_TIC_TIC_TIC" c_CasADi__flattencat_TIC_TIC_TIC+ :: Ptr (CppVec (Ptr MX')) -> IO (Ptr MX')+flattencat'''+ :: Vector MX -> IO MX+flattencat''' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__flattencat_TIC_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++foreign import ccall unsafe "CasADi__vecNZcat_TIC_TIC_TIC" c_CasADi__vecNZcat_TIC_TIC_TIC+ :: Ptr (CppVec (Ptr MX')) -> IO (Ptr MX')+vecNZcat'''+ :: Vector MX -> IO MX+vecNZcat''' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__vecNZcat_TIC_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++foreign import ccall unsafe "CasADi__flattenNZcat_TIC_TIC_TIC" c_CasADi__flattenNZcat_TIC_TIC_TIC+ :: Ptr (CppVec (Ptr MX')) -> IO (Ptr MX')+flattenNZcat'''+ :: Vector MX -> IO MX+flattenNZcat''' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__flattenNZcat_TIC_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++foreign import ccall unsafe "CasADi__norm_F_TIC_TIC_TIC" c_CasADi__norm_F_TIC_TIC_TIC+ :: Ptr MX' -> IO (Ptr MX')+norm_F'''+ :: MX -> IO MX+norm_F''' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__norm_F_TIC_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++foreign import ccall unsafe "CasADi__norm_2_TIC_TIC_TIC" c_CasADi__norm_2_TIC_TIC_TIC+ :: Ptr MX' -> IO (Ptr MX')+norm_2'''+ :: MX -> IO MX+norm_2''' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__norm_2_TIC_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++foreign import ccall unsafe "CasADi__norm_1_TIC_TIC_TIC" c_CasADi__norm_1_TIC_TIC_TIC+ :: Ptr MX' -> IO (Ptr MX')+norm_1'''+ :: MX -> IO MX+norm_1''' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__norm_1_TIC_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++foreign import ccall unsafe "CasADi__norm_inf_TIC_TIC_TIC" c_CasADi__norm_inf_TIC_TIC_TIC+ :: Ptr MX' -> IO (Ptr MX')+norm_inf'''+ :: MX -> IO MX+norm_inf''' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__norm_inf_TIC_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++foreign import ccall unsafe "CasADi__trans_TIC_TIC_TIC_TIC" c_CasADi__trans_TIC_TIC_TIC_TIC+ :: Ptr MX' -> IO (Ptr MX')+trans''''+ :: MX -> IO MX+trans'''' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__trans_TIC_TIC_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++foreign import ccall unsafe "CasADi__mul_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__mul_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC+ :: Ptr MX' -> Ptr MX' -> Ptr CRSSparsity' -> IO (Ptr MX')+mul''''''''''+ :: MX -> MX -> CRSSparsity -> IO MX+mul'''''''''' x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__mul_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++foreign import ccall unsafe "CasADi__mul_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__mul_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC+ :: Ptr MX' -> Ptr MX' -> IO (Ptr MX')+mul'''''''''''+ :: MX -> MX -> IO MX+mul''''''''''' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__mul_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++foreign import ccall unsafe "CasADi__mul_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__mul_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC+ :: Ptr (CppVec (Ptr MX')) -> IO (Ptr MX')+mul''''''''''''+ :: Vector MX -> IO MX+mul'''''''''''' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__mul_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++foreign import ccall unsafe "CasADi__inner_prod_TIC_TIC_TIC" c_CasADi__inner_prod_TIC_TIC_TIC+ :: Ptr MX' -> Ptr MX' -> IO (Ptr MX')+inner_prod'''+ :: MX -> MX -> IO MX+inner_prod''' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__inner_prod_TIC_TIC_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++foreign import ccall unsafe "CasADi__outer_prod_TIC_TIC_TIC" c_CasADi__outer_prod_TIC_TIC_TIC+ :: Ptr MX' -> Ptr MX' -> IO (Ptr MX')+outer_prod'''+ :: MX -> MX -> IO MX+outer_prod''' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__outer_prod_TIC_TIC_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++foreign import ccall unsafe "CasADi__if_else_TIC" c_CasADi__if_else_TIC+ :: Ptr MX' -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')+if_else'+ :: MX -> MX -> MX -> IO MX+if_else' x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__if_else_TIC x0' x1' x2' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++foreign import ccall unsafe "CasADi__reshape_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__reshape_TIC_TIC_TIC_TIC_TIC_TIC_TIC+ :: Ptr MX' -> Ptr CRSSparsity' -> IO (Ptr MX')+reshape'''''''+ :: MX -> CRSSparsity -> IO MX+reshape''''''' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__reshape_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++foreign import ccall unsafe "CasADi__vec_TIC_TIC_TIC_TIC" c_CasADi__vec_TIC_TIC_TIC_TIC+ :: Ptr MX' -> IO (Ptr MX')+vec''''+ :: MX -> IO MX+vec'''' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__vec_TIC_TIC_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++foreign import ccall unsafe "CasADi__flatten_TIC_TIC_TIC" c_CasADi__flatten_TIC_TIC_TIC+ :: Ptr MX' -> IO (Ptr MX')+flatten'''+ :: MX -> IO MX+flatten''' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__flatten_TIC_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++foreign import ccall unsafe "CasADi__vecNZ_TIC_TIC_TIC" c_CasADi__vecNZ_TIC_TIC_TIC+ :: Ptr MX' -> IO (Ptr MX')+vecNZ'''+ :: MX -> IO MX+vecNZ''' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__vecNZ_TIC_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++foreign import ccall unsafe "CasADi__flattenNZ_TIC_TIC_TIC" c_CasADi__flattenNZ_TIC_TIC_TIC+ :: Ptr MX' -> IO (Ptr MX')+flattenNZ'''+ :: MX -> IO MX+flattenNZ''' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__flattenNZ_TIC_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++foreign import ccall unsafe "CasADi__unite_TIC_TIC_TIC" c_CasADi__unite_TIC_TIC_TIC+ :: Ptr MX' -> Ptr MX' -> IO (Ptr MX')+unite'''+ :: MX -> MX -> IO MX+unite''' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__unite_TIC_TIC_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++foreign import ccall unsafe "CasADi__isSymbolic_TIC" c_CasADi__isSymbolic_TIC+ :: Ptr MX' -> IO (Ptr CppBool')+isSymbolic'+ :: MX -> IO Bool+isSymbolic' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__isSymbolic_TIC x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++foreign import ccall unsafe "CasADi__isSymbolicSparse_TIC" c_CasADi__isSymbolicSparse_TIC+ :: Ptr MX' -> IO (Ptr CppBool')+isSymbolicSparse'+ :: MX -> IO Bool+isSymbolicSparse' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__isSymbolicSparse_TIC x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++foreign import ccall unsafe "CasADi__isIdentity_TIC_TIC_TIC" c_CasADi__isIdentity_TIC_TIC_TIC+ :: Ptr MX' -> IO (Ptr CppBool')+isIdentity'''+ :: MX -> IO Bool+isIdentity''' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__isIdentity_TIC_TIC_TIC x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++foreign import ccall unsafe "CasADi__isZero_TIC_TIC_TIC" c_CasADi__isZero_TIC_TIC_TIC+ :: Ptr MX' -> IO (Ptr CppBool')+isZero'''+ :: MX -> IO Bool+isZero''' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__isZero_TIC_TIC_TIC x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++foreign import ccall unsafe "CasADi__isOne_TIC_TIC_TIC" c_CasADi__isOne_TIC_TIC_TIC+ :: Ptr MX' -> IO (Ptr CppBool')+isOne'''+ :: MX -> IO Bool+isOne''' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__isOne_TIC_TIC_TIC x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++foreign import ccall unsafe "CasADi__simplify_TIC_TIC" c_CasADi__simplify_TIC_TIC+ :: Ptr MX' -> IO ()+simplify''+ :: MX -> IO ()+simplify'' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__simplify_TIC_TIC x0' >>= wrapReturn++foreign import ccall unsafe "CasADi__isTranspose" c_CasADi__isTranspose+ :: Ptr MX' -> IO (Ptr CppBool')+{-|+>Is the expression a transpose?+-}+isTranspose+ :: MX -> IO Bool+isTranspose x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__isTranspose x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++foreign import ccall unsafe "CasADi__isMinusOne_TIC_TIC_TIC" c_CasADi__isMinusOne_TIC_TIC_TIC+ :: Ptr MX' -> IO (Ptr CppBool')+isMinusOne'''+ :: MX -> IO Bool+isMinusOne''' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__isMinusOne_TIC_TIC_TIC x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++foreign import ccall unsafe "CasADi__isVector_TIC_TIC_TIC" c_CasADi__isVector_TIC_TIC_TIC+ :: Ptr MX' -> IO (Ptr CppBool')+isVector'''+ :: MX -> IO Bool+isVector''' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__isVector_TIC_TIC_TIC x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++foreign import ccall unsafe "CasADi__isDense_TIC_TIC_TIC" c_CasADi__isDense_TIC_TIC_TIC+ :: Ptr MX' -> IO (Ptr CppBool')+isDense'''+ :: MX -> IO Bool+isDense''' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__isDense_TIC_TIC_TIC x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++foreign import ccall unsafe "CasADi__isRegular_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__isRegular_TIC_TIC_TIC_TIC_TIC_TIC+ :: Ptr MX' -> IO (Ptr CppBool')+isRegular''''''+ :: MX -> IO Bool+isRegular'''''' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__isRegular_TIC_TIC_TIC_TIC_TIC_TIC x0' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++foreign import ccall unsafe "CasADi__trace_TIC_TIC_TIC" c_CasADi__trace_TIC_TIC_TIC+ :: Ptr MX' -> IO (Ptr MX')+trace'''+ :: MX -> IO MX+trace''' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__trace_TIC_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++foreign import ccall unsafe "CasADi__repmat_TIC_TIC_TIC" c_CasADi__repmat_TIC_TIC_TIC+ :: Ptr MX' -> CInt -> CInt -> IO (Ptr MX')+repmat'''+ :: MX -> Int -> Int -> IO MX+repmat''' x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__repmat_TIC_TIC_TIC x0' x1' x2' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++foreign import ccall unsafe "CasADi__makeDense_TIC_TIC_TIC" c_CasADi__makeDense_TIC_TIC_TIC+ :: Ptr MX' -> IO ()+makeDense'''+ :: MX -> IO ()+makeDense''' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__makeDense_TIC_TIC_TIC x0' >>= wrapReturn++foreign import ccall unsafe "CasADi__densify_TIC_TIC_TIC" c_CasADi__densify_TIC_TIC_TIC+ :: Ptr MX' -> IO (Ptr MX')+densify'''+ :: MX -> IO MX+densify''' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__densify_TIC_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++foreign import ccall unsafe "CasADi__full_TIC_TIC_TIC" c_CasADi__full_TIC_TIC_TIC+ :: Ptr MX' -> IO (Ptr MX')+full'''+ :: MX -> IO MX+full''' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__full_TIC_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++foreign import ccall unsafe "CasADi__createParent" c_CasADi__createParent+ :: Ptr (CppVec (Ptr MX')) -> IO (Ptr MX')+{-|+>> MX CasADi::createParent(std::vector< MX > &deps)+>------------------------------------------------------------------------+>+>Create a parent MX on which all given MX's will depend.+>+>In some sense, this function is the inverse of+>+>Parameters:+>-----------+>+>deps: Must all be symbolic matrices.+>+>> std::pair< MX, std::vector< MX > > CasADi::createParent(const std::vector< CRSSparsity > &deps)+>+>> std::pair< MX, std::vector< MX > > CasADi::createParent(const std::vector< MX > &deps)+>------------------------------------------------------------------------+>+>Create a parent MX on which a bunch of MX's (sizes given as argument) will+>depend.+-}+createParent+ :: Vector MX -> IO MX+createParent x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__createParent x0' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++foreign import ccall unsafe "CasADi__countNodes_TIC" c_CasADi__countNodes_TIC+ :: Ptr MX' -> IO CInt+countNodes'+ :: MX -> IO Int+countNodes' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__countNodes_TIC x0' >>= wrapReturn++foreign import ccall unsafe "CasADi__diag_TIC_TIC_TIC" c_CasADi__diag_TIC_TIC_TIC+ :: Ptr MX' -> IO (Ptr MX')+diag'''+ :: MX -> IO MX+diag''' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__diag_TIC_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++foreign import ccall unsafe "CasADi__blkdiag_TIC_TIC_TIC_TIC" c_CasADi__blkdiag_TIC_TIC_TIC_TIC+ :: Ptr (CppVec (Ptr MX')) -> IO (Ptr MX')+blkdiag''''+ :: Vector MX -> IO MX+blkdiag'''' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__blkdiag_TIC_TIC_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++foreign import ccall unsafe "CasADi__sumRows_TIC_TIC_TIC" c_CasADi__sumRows_TIC_TIC_TIC+ :: Ptr MX' -> IO (Ptr MX')+sumRows'''+ :: MX -> IO MX+sumRows''' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__sumRows_TIC_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++foreign import ccall unsafe "CasADi__sumCols_TIC_TIC_TIC" c_CasADi__sumCols_TIC_TIC_TIC+ :: Ptr MX' -> IO (Ptr MX')+sumCols'''+ :: MX -> IO MX+sumCols''' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__sumCols_TIC_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++foreign import ccall unsafe "CasADi__sumAll_TIC_TIC_TIC" c_CasADi__sumAll_TIC_TIC_TIC+ :: Ptr MX' -> IO (Ptr MX')+sumAll'''+ :: MX -> IO MX+sumAll''' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__sumAll_TIC_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++foreign import ccall unsafe "CasADi__polyval_TIC_TIC_TIC" c_CasADi__polyval_TIC_TIC_TIC+ :: Ptr MX' -> Ptr MX' -> IO (Ptr MX')+polyval'''+ :: MX -> MX -> IO MX+polyval''' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__polyval_TIC_TIC_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++foreign import ccall unsafe "CasADi__msym" c_CasADi__msym+ :: Ptr StdString' -> CInt -> CInt -> IO (Ptr MX')+{-|+>> MX CasADi::msym(const std::string &name, int n=1, int m=1)+>------------------------------------------------------------------------+>+>Construct symbolic arrays and variables using CasADi's MX expression graph+>representation The "msym" function is intended to work in a similar way as+>"sym" used in the Symbolic Toolbox for Matlab but instead creating an MX+>object. The MX expression graph is more general but also have considerably+>more overhead than the alternative SX expression graph.+>+>Create a matrix symbolic variable of given sparsity+>+>> MX CasADi::msym(const std::string &name, const std::pair< int, int > &nm)+>+>> MX CasADi::msym(const std::string &name, const CRSSparsity &sp)+>------------------------------------------------------------------------+>+>Create a matrix symbolic variable of given sparsity.+>+>> MX CasADi::msym(const Matrix< double > &x)+>------------------------------------------------------------------------+>+>Create a matrix variable from a constant matrix.+>+>> std::vector< MX > CasADi::msym(const std::string &name, const CRSSparsity &sp, int p)+>------------------------------------------------------------------------+>+>Create a vector of length p with with matrix symbolic variables of given+>sparsity.+>+>> std::vector< std::vector< MX > > CasADi::msym(const std::string &name, const CRSSparsity &sp, int p, int r)+>------------------------------------------------------------------------+>+>Create a vector of length r of vectors of length p with matrix symbolic+>variables with given sparsity.+>+>> std::vector< MX > CasADi::msym(const std::string &name, int n, int m, int p)+>------------------------------------------------------------------------+>+>Create a vector of length p with n-by-m matrix symbolic variables.+>+>> std::vector< std::vector< MX > > CasADi::msym(const std::string &name, int n, int m, int p, int r)+>------------------------------------------------------------------------+>+>Create a vector of length r of vectors of length p with n-by-m matrices with+>symbolic variables.+-}+msym+ :: String -> Int -> Int -> IO MX+msym x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__msym x0' x1' x2' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++foreign import ccall unsafe "CasADi__msym_TIC" c_CasADi__msym_TIC+ :: Ptr StdString' -> CInt -> IO (Ptr MX')+msym'+ :: String -> Int -> IO MX+msym' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__msym_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++foreign import ccall unsafe "CasADi__msym_TIC_TIC" c_CasADi__msym_TIC_TIC+ :: Ptr StdString' -> IO (Ptr MX')+msym''+ :: String -> IO MX+msym'' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__msym_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++foreign import ccall unsafe "CasADi__msym_TIC_TIC_TIC" c_CasADi__msym_TIC_TIC_TIC+ :: Ptr DMatrix' -> IO (Ptr MX')+msym'''+ :: DMatrix -> IO MX+msym''' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__msym_TIC_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++foreign import ccall unsafe "CasADi__msym_TIC_TIC_TIC_TIC" c_CasADi__msym_TIC_TIC_TIC_TIC+ :: Ptr StdString' -> Ptr CRSSparsity' -> IO (Ptr MX')+msym''''+ :: String -> CRSSparsity -> IO MX+msym'''' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__msym_TIC_TIC_TIC_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++foreign import ccall unsafe "CasADi__msym_TIC_TIC_TIC_TIC_TIC" c_CasADi__msym_TIC_TIC_TIC_TIC_TIC+ :: Ptr StdString' -> Ptr CRSSparsity' -> CInt -> IO (Ptr (CppVec (Ptr MX')))+msym'''''+ :: String -> CRSSparsity -> Int -> IO (Vector MX)+msym''''' x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__msym_TIC_TIC_TIC_TIC_TIC x0' x1' x2' >>= (newForeignPtr c_delete_std__vector_CasADi__MX_) >>= wrapReturn++foreign import ccall unsafe "CasADi__msym_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__msym_TIC_TIC_TIC_TIC_TIC_TIC+ :: Ptr StdString' -> CInt -> CInt -> CInt -> IO (Ptr (CppVec (Ptr MX')))+msym''''''+ :: String -> Int -> Int -> Int -> IO (Vector MX)+msym'''''' x0 x1 x2 x3 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ withMarshal x3 $ \x3' ->+ c_CasADi__msym_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' x3' >>= (newForeignPtr c_delete_std__vector_CasADi__MX_) >>= wrapReturn++foreign import ccall unsafe "CasADi__msym_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__msym_TIC_TIC_TIC_TIC_TIC_TIC_TIC+ :: Ptr StdString' -> Ptr CRSSparsity' -> CInt -> CInt -> IO (Ptr (CppVecVec (Ptr MX')))+msym'''''''+ :: String -> CRSSparsity -> Int -> Int -> IO (Vector (Vector MX))+msym''''''' x0 x1 x2 x3 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ withMarshal x3 $ \x3' ->+ c_CasADi__msym_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' x3' >>= (newForeignPtr c_delete_std__vector_std__vector_CasADi__MX__) >>= wrapReturn++foreign import ccall unsafe "CasADi__msym_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__msym_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC+ :: Ptr StdString' -> CInt -> CInt -> CInt -> CInt -> IO (Ptr (CppVecVec (Ptr MX')))+msym''''''''+ :: String -> Int -> Int -> Int -> Int -> IO (Vector (Vector MX))+msym'''''''' x0 x1 x2 x3 x4 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ withMarshal x3 $ \x3' ->+ withMarshal x4 $ \x4' ->+ c_CasADi__msym_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' x3' x4' >>= (newForeignPtr c_delete_std__vector_std__vector_CasADi__MX__) >>= wrapReturn++foreign import ccall unsafe "CasADi__isEqual_TIC_TIC_TIC" c_CasADi__isEqual_TIC_TIC_TIC+ :: Ptr MX' -> Ptr MX' -> IO (Ptr CppBool')+isEqual'''+ :: MX -> MX -> IO Bool+isEqual''' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__isEqual_TIC_TIC_TIC x0' x1' >>= (newForeignPtr c_delete_bool) >>= wrapReturn++foreign import ccall unsafe "CasADi__getOperatorRepresentation_TIC" c_CasADi__getOperatorRepresentation_TIC+ :: Ptr MX' -> Ptr (CppVec (Ptr StdString')) -> IO (Ptr StdString')+getOperatorRepresentation'+ :: MX -> Vector String -> IO String+getOperatorRepresentation' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal (CornerCase x1) $ \x1' ->+ c_CasADi__getOperatorRepresentation_TIC x0' x1' >>= (newForeignPtr c_delete_std__string) >>= wrapReturn++foreign import ccall unsafe "CasADi__substitute_TIC_TIC" c_CasADi__substitute_TIC_TIC+ :: Ptr MX' -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')+substitute''+ :: MX -> MX -> MX -> IO MX+substitute'' x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__substitute_TIC_TIC x0' x1' x2' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++foreign import ccall unsafe "CasADi__substitute_TIC_TIC_TIC" c_CasADi__substitute_TIC_TIC_TIC+ :: Ptr (CppVec (Ptr MX')) -> Ptr (CppVec (Ptr MX')) -> Ptr (CppVec (Ptr MX')) -> IO (Ptr (CppVec (Ptr MX')))+substitute'''+ :: Vector MX -> Vector MX -> Vector MX -> IO (Vector MX)+substitute''' x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__substitute_TIC_TIC_TIC x0' x1' x2' >>= (newForeignPtr c_delete_std__vector_CasADi__MX_) >>= wrapReturn++foreign import ccall unsafe "CasADi__graph_substitute" c_CasADi__graph_substitute+ :: Ptr MX' -> Ptr (CppVec (Ptr MX')) -> Ptr (CppVec (Ptr MX')) -> IO (Ptr MX')+{-|+>> MX CasADi::graph_substitute(const MX &ex, const std::vector< MX > &v, const std::vector< MX > &vdef)+>------------------------------------------------------------------------+>+>Substitute variable v with expression vdef in an expression ex, preserving+>nodes.+>+>> std::vector< MX > CasADi::graph_substitute(const std::vector< MX > &ex, const std::vector< MX > &v, const std::vector< MX > &vdef)+>------------------------------------------------------------------------+>+>Substitute variable var with expression expr in multiple expressions,+>preserving nodes.+-}+graph_substitute+ :: MX -> Vector MX -> Vector MX -> IO MX+graph_substitute x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__graph_substitute x0' x1' x2' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++foreign import ccall unsafe "CasADi__graph_substitute_TIC" c_CasADi__graph_substitute_TIC+ :: Ptr (CppVec (Ptr MX')) -> Ptr (CppVec (Ptr MX')) -> Ptr (CppVec (Ptr MX')) -> IO (Ptr (CppVec (Ptr MX')))+graph_substitute'+ :: Vector MX -> Vector MX -> Vector MX -> IO (Vector MX)+graph_substitute' x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__graph_substitute_TIC x0' x1' x2' >>= (newForeignPtr c_delete_std__vector_CasADi__MX_) >>= wrapReturn++foreign import ccall unsafe "CasADi__substituteInPlace_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__substituteInPlace_TIC_TIC_TIC_TIC_TIC_TIC+ :: Ptr (CppVec (Ptr MX')) -> Ptr (CppVec (Ptr MX')) -> Ptr CppBool' -> IO ()+substituteInPlace''''''+ :: Vector MX -> Vector MX -> Bool -> IO ()+substituteInPlace'''''' x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__substituteInPlace_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' >>= wrapReturn++foreign import ccall unsafe "CasADi__substituteInPlace_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__substituteInPlace_TIC_TIC_TIC_TIC_TIC_TIC_TIC+ :: Ptr (CppVec (Ptr MX')) -> Ptr (CppVec (Ptr MX')) -> IO ()+substituteInPlace'''''''+ :: Vector MX -> Vector MX -> IO ()+substituteInPlace''''''' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__substituteInPlace_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' >>= wrapReturn++foreign import ccall unsafe "CasADi__substituteInPlace_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__substituteInPlace_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC+ :: Ptr (CppVec (Ptr MX')) -> Ptr (CppVec (Ptr MX')) -> Ptr (CppVec (Ptr MX')) -> Ptr CppBool' -> IO ()+substituteInPlace''''''''+ :: Vector MX -> Vector MX -> Vector MX -> Bool -> IO ()+substituteInPlace'''''''' x0 x1 x2 x3 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ withMarshal x3 $ \x3' ->+ c_CasADi__substituteInPlace_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn++foreign import ccall unsafe "CasADi__substituteInPlace_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__substituteInPlace_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC+ :: Ptr (CppVec (Ptr MX')) -> Ptr (CppVec (Ptr MX')) -> Ptr (CppVec (Ptr MX')) -> IO ()+substituteInPlace'''''''''+ :: Vector MX -> Vector MX -> Vector MX -> IO ()+substituteInPlace''''''''' x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__substituteInPlace_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC x0' x1' x2' >>= wrapReturn++foreign import ccall unsafe "CasADi__extractShared_TIC_TIC_TIC" c_CasADi__extractShared_TIC_TIC_TIC+ :: Ptr (CppVec (Ptr MX')) -> Ptr (CppVec (Ptr MX')) -> Ptr (CppVec (Ptr MX')) -> Ptr StdString' -> Ptr StdString' -> IO ()+extractShared'''+ :: Vector MX -> Vector MX -> Vector MX -> String -> String -> IO ()+extractShared''' x0 x1 x2 x3 x4 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ withMarshal x3 $ \x3' ->+ withMarshal x4 $ \x4' ->+ c_CasADi__extractShared_TIC_TIC_TIC x0' x1' x2' x3' x4' >>= wrapReturn++foreign import ccall unsafe "CasADi__extractShared_TIC_TIC_TIC_TIC" c_CasADi__extractShared_TIC_TIC_TIC_TIC+ :: Ptr (CppVec (Ptr MX')) -> Ptr (CppVec (Ptr MX')) -> Ptr (CppVec (Ptr MX')) -> Ptr StdString' -> IO ()+extractShared''''+ :: Vector MX -> Vector MX -> Vector MX -> String -> IO ()+extractShared'''' x0 x1 x2 x3 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ withMarshal x3 $ \x3' ->+ c_CasADi__extractShared_TIC_TIC_TIC_TIC x0' x1' x2' x3' >>= wrapReturn++foreign import ccall unsafe "CasADi__extractShared_TIC_TIC_TIC_TIC_TIC" c_CasADi__extractShared_TIC_TIC_TIC_TIC_TIC+ :: Ptr (CppVec (Ptr MX')) -> Ptr (CppVec (Ptr MX')) -> Ptr (CppVec (Ptr MX')) -> IO ()+extractShared'''''+ :: Vector MX -> Vector MX -> Vector MX -> IO ()+extractShared''''' x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__extractShared_TIC_TIC_TIC_TIC_TIC x0' x1' x2' >>= wrapReturn++foreign import ccall unsafe "CasADi__printCompact_TIC_TIC_TIC" c_CasADi__printCompact_TIC_TIC_TIC+ :: Ptr MX' -> IO ()+printCompact'''+ :: MX -> IO ()+printCompact''' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__printCompact_TIC_TIC_TIC x0' >>= wrapReturn++foreign import ccall unsafe "CasADi__jacobian_TIC" c_CasADi__jacobian_TIC+ :: Ptr MX' -> Ptr MX' -> IO (Ptr MX')+jacobian'+ :: MX -> MX -> IO MX+jacobian' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__jacobian_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++foreign import ccall unsafe "CasADi__gradient_TIC" c_CasADi__gradient_TIC+ :: Ptr MX' -> Ptr MX' -> IO (Ptr MX')+gradient'+ :: MX -> MX -> IO MX+gradient' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__gradient_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++foreign import ccall unsafe "CasADi__tangent_TIC" c_CasADi__tangent_TIC+ :: Ptr MX' -> Ptr MX' -> IO (Ptr MX')+tangent'+ :: MX -> MX -> IO MX+tangent' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__tangent_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++foreign import ccall unsafe "CasADi__nullspace_TIC_TIC_TIC" c_CasADi__nullspace_TIC_TIC_TIC+ :: Ptr MX' -> IO (Ptr MX')+nullspace'''+ :: MX -> IO MX+nullspace''' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__nullspace_TIC_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++foreign import ccall unsafe "CasADi__det_TIC_TIC_TIC" c_CasADi__det_TIC_TIC_TIC+ :: Ptr MX' -> IO (Ptr MX')+det'''+ :: MX -> IO MX+det''' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__det_TIC_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++foreign import ccall unsafe "CasADi__inv_TIC_TIC_TIC" c_CasADi__inv_TIC_TIC_TIC+ :: Ptr MX' -> IO (Ptr MX')+inv'''+ :: MX -> IO MX+inv''' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__inv_TIC_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++foreign import ccall unsafe "CasADi__getSymbols_TIC" c_CasADi__getSymbols_TIC+ :: Ptr MX' -> IO (Ptr (CppVec (Ptr MX')))+getSymbols'+ :: MX -> IO (Vector MX)+getSymbols' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__getSymbols_TIC x0' >>= (newForeignPtr c_delete_std__vector_CasADi__MX_) >>= wrapReturn++foreign import ccall unsafe "CasADi__getSymbols_TIC_TIC" c_CasADi__getSymbols_TIC_TIC+ :: Ptr (CppVec (Ptr MX')) -> IO (Ptr (CppVec (Ptr MX')))+getSymbols''+ :: Vector MX -> IO (Vector MX)+getSymbols'' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__getSymbols_TIC_TIC x0' >>= (newForeignPtr c_delete_std__vector_CasADi__MX_) >>= wrapReturn++foreign import ccall unsafe "CasADi__matrix_expand" c_CasADi__matrix_expand+ :: Ptr MX' -> Ptr (CppVec (Ptr MX')) -> IO (Ptr MX')+{-|+>Expand MX graph to SXFunction call.+>+>Expand the given expression e, optionally supplying expressions contained in+>it at which expansion should stop.+-}+matrix_expand+ :: MX -> Vector MX -> IO MX+matrix_expand x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__matrix_expand x0' x1' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++foreign import ccall unsafe "CasADi__matrix_expand_TIC" c_CasADi__matrix_expand_TIC+ :: Ptr MX' -> IO (Ptr MX')+matrix_expand'+ :: MX -> IO MX+matrix_expand' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__matrix_expand_TIC x0' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++foreign import ccall unsafe "CasADi__matrix_expand_TIC_TIC" c_CasADi__matrix_expand_TIC_TIC+ :: Ptr (CppVec (Ptr MX')) -> Ptr (CppVec (Ptr MX')) -> IO (Ptr (CppVec (Ptr MX')))+matrix_expand''+ :: Vector MX -> Vector MX -> IO (Vector MX)+matrix_expand'' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__matrix_expand_TIC_TIC x0' x1' >>= (newForeignPtr c_delete_std__vector_CasADi__MX_) >>= wrapReturn++foreign import ccall unsafe "CasADi__matrix_expand_TIC_TIC_TIC" c_CasADi__matrix_expand_TIC_TIC_TIC+ :: Ptr (CppVec (Ptr MX')) -> IO (Ptr (CppVec (Ptr MX')))+matrix_expand'''+ :: Vector MX -> IO (Vector MX)+matrix_expand''' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__matrix_expand_TIC_TIC_TIC x0' >>= (newForeignPtr c_delete_std__vector_CasADi__MX_) >>= wrapReturn++foreign import ccall unsafe "CasADi__kron_TIC_TIC_TIC" c_CasADi__kron_TIC_TIC_TIC+ :: Ptr MX' -> Ptr MX' -> IO (Ptr MX')+kron'''+ :: MX -> MX -> IO MX+kron''' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__kron_TIC_TIC_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__MX) >>= wrapReturn++foreign import ccall unsafe "CasADi__parameterizeTime" c_CasADi__parameterizeTime+ :: Ptr FX' -> IO (Ptr FX')+{-|+>make integration start and end time a parameter Applies the conversion t =+>t0 + (tf-t0)*tau to the supplied dae. with tau dimensionless time. The+>Input/OuputScheme of the result is the same as the scheme of the dae, except+>for input(DAE_P), which is extended by t0 and tf at the top.+-}+parameterizeTime+ :: FX -> IO FX+parameterizeTime x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__parameterizeTime x0' >>= (newForeignPtr c_delete_CasADi__FX) >>= wrapReturn++foreign import ccall unsafe "CasADi__parameterizeTimeOutput" c_CasADi__parameterizeTimeOutput+ :: Ptr FX' -> IO (Ptr FX')+{-|+>adapts an output function such that start and end time are parameters+>Applies the conversion t = t0 + (tf-t0)*tau to the supplied dae. with tau+>dimensionless time. The InputScheme of the result is the same as the scheme+>of the dae, except for input(DAE_P), which is extended by t0 and tf at the+>top.+-}+parameterizeTimeOutput+ :: FX -> IO FX+parameterizeTimeOutput x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__parameterizeTimeOutput x0' >>= (newForeignPtr c_delete_CasADi__FX) >>= wrapReturn++foreign import ccall unsafe "CasADi__numSample1D" c_CasADi__numSample1D+ :: Ptr FX' -> Ptr DMatrix' -> IO (Ptr DMatrix')+{-|+>sample a function on a 1D grid+>+>Parameters:+>-----------+>+>fx: an initialized function mapping from single p-by-1 to single m-by-n+>+>a: grid of numbers p-by-N+>+>For each column in the grid, fx is numerically evaluated and the output is+>put in a resulting matrix of size m-by-n*p+>+>If your fx is really multiple output, and you wish to use a particular+>output, use the slice operator on the fx.+>+>See: evalf+-}+numSample1D+ :: FX -> DMatrix -> IO DMatrix+numSample1D x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__numSample1D x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++foreign import ccall unsafe "CasADi__numSample1DT" c_CasADi__numSample1DT+ :: Ptr FX' -> Ptr DMatrix' -> IO (Ptr DMatrix')+{-|+>sample a function on a 1D grid+>+>Parameters:+>-----------+>+>fx: an initialized function mapping from single p-by-1 to single m-by-n+>+>a: grid of numbers p-by-N+>+>For each column in the grid, fx is numerically evaluated and the output is+>put in a resulting matrix of size m*p-by-n+>+>If your fx is really multiple output, and you wish to use a particular+>output, use the slice operator on the fx.+-}+numSample1DT+ :: FX -> DMatrix -> IO DMatrix+numSample1DT x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__numSample1DT x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++foreign import ccall unsafe "CasADi__numSample2D" c_CasADi__numSample2D+ :: Ptr FX' -> Ptr DMatrix' -> IO (Ptr DMatrix')+{-|+>sample a function on a 2D grid+>+>Parameters:+>-----------+>+>fx: an initialized function mapping from (1-by-1,1-by-1) to single m-by-n+>+>a: grid of numbers+>+>For each point (i,j) in the grid, fx is numerically evaluated and the output+>is put in a matrix+>+>If your fx is really multiple output, and you wish to use a particular+>output, use the slice operator on the fx.+-}+numSample2D+ :: FX -> DMatrix -> IO DMatrix+numSample2D x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__numSample2D x0' x1' >>= (newForeignPtr c_delete_CasADi__Matrix_double_) >>= wrapReturn++foreign import ccall unsafe "CasADi__vec_TIC_TIC_TIC_TIC_TIC" c_CasADi__vec_TIC_TIC_TIC_TIC_TIC+ :: Ptr SXFunction' -> IO (Ptr SXFunction')+vec'''''+ :: SXFunction -> IO SXFunction+vec''''' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__vec_TIC_TIC_TIC_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__SXFunction) >>= wrapReturn++foreign import ccall unsafe "CasADi__vec_TIC_TIC_TIC_TIC_TIC_TIC" c_CasADi__vec_TIC_TIC_TIC_TIC_TIC_TIC+ :: Ptr FX' -> IO (Ptr MXFunction')+vec''''''+ :: FX -> IO MXFunction+vec'''''' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__vec_TIC_TIC_TIC_TIC_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__MXFunction) >>= wrapReturn++foreign import ccall unsafe "CasADi__collocationPoints" c_CasADi__collocationPoints+ :: CInt -> Ptr StdString' -> IO (Ptr (CppVec CDouble))+{-|+>Obtain collocation points of specific order and scheme.+>+>Parameters:+>-----------+>+>scheme: 'radau' or 'legendre'+-}+collocationPoints+ :: Int -> String -> IO (Vector Double)+collocationPoints x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__collocationPoints x0' x1' >>= (newForeignPtr c_delete_std__vector_double_) >>= wrapReturn++foreign import ccall unsafe "CasADi__collocationPoints_TIC" c_CasADi__collocationPoints_TIC+ :: CInt -> IO (Ptr (CppVec CDouble))+collocationPoints'+ :: Int -> IO (Vector Double)+collocationPoints' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__collocationPoints_TIC x0' >>= (newForeignPtr c_delete_std__vector_double_) >>= wrapReturn++foreign import ccall unsafe "CasADi__collocationInterpolators" c_CasADi__collocationInterpolators+ :: Ptr (CppVec CDouble) -> Ptr (CppVecVec CDouble) -> Ptr (CppVec CDouble) -> IO ()+{-|+>Obtain collocation interpolating matrices.+>+>Parameters:+>-----------+>+>tau_root: location of collocation points, as obtained from+>collocationPoints+>+>C: interpolating coefficients to obtain derivatives Length: order+1, order+>+ 1+>+>dX/dt (j) ~ Sum_i C[j][i]*X(i)+>+>Parameters:+>-----------+>+>D: interpolating coefficients to obtain end state Length: order+1+-}+collocationInterpolators+ :: Vector Double -> Vector (Vector Double) -> Vector Double -> IO ()+collocationInterpolators x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__collocationInterpolators x0' x1' x2' >>= wrapReturn++foreign import ccall unsafe "CasADi__explicitRK" c_CasADi__explicitRK+ :: Ptr FX' -> Ptr MX' -> CInt -> CInt -> IO (Ptr FX')+{-|+>Construct an explicit Runge-Kutta integrator.+>+>Parameters:+>-----------+>+>f: dynamical system+>+>>Input scheme: CasADi::DAEInput (DAE_NUM_IN = 5) [daeIn]+>+-----------+-------+----------------------------++>| Full name | Short | Description |+>+===========+=======+============================++>| DAE_X | x | Differential state . |+>+-----------+-------+----------------------------++>| DAE_Z | z | Algebraic state . |+>+-----------+-------+----------------------------++>| DAE_P | p | Parameter . |+>+-----------+-------+----------------------------++>| DAE_T | t | Explicit time dependence . |+>+-----------+-------+----------------------------++>+>>Output scheme: CasADi::DAEOutput (DAE_NUM_OUT = 4) [daeOut]+>+-----------+-------+--------------------------------------------++>| Full name | Short | Description |+>+===========+=======+============================================++>| DAE_ODE | ode | Right hand side of the implicit ODE . |+>+-----------+-------+--------------------------------------------++>| DAE_ALG | alg | Right hand side of algebraic equations . |+>+-----------+-------+--------------------------------------------++>| DAE_QUAD | quad | Right hand side of quadratures equations . |+>+-----------+-------+--------------------------------------------++>+>Parameters:+>-----------+>+>tf: Integration end time+>+>order: Order of integration+>+>ne: Number of times the RK primitive is repeated over the integration+>interval+-}+explicitRK+ :: FX -> MX -> Int -> Int -> IO FX+explicitRK x0 x1 x2 x3 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ withMarshal x3 $ \x3' ->+ c_CasADi__explicitRK x0' x1' x2' x3' >>= (newForeignPtr c_delete_CasADi__FX) >>= wrapReturn++foreign import ccall unsafe "CasADi__explicitRK_TIC" c_CasADi__explicitRK_TIC+ :: Ptr FX' -> Ptr MX' -> CInt -> IO (Ptr FX')+explicitRK'+ :: FX -> MX -> Int -> IO FX+explicitRK' x0 x1 x2 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ withMarshal x2 $ \x2' ->+ c_CasADi__explicitRK_TIC x0' x1' x2' >>= (newForeignPtr c_delete_CasADi__FX) >>= wrapReturn++foreign import ccall unsafe "CasADi__explicitRK_TIC_TIC" c_CasADi__explicitRK_TIC_TIC+ :: Ptr FX' -> Ptr MX' -> IO (Ptr FX')+explicitRK''+ :: FX -> MX -> IO FX+explicitRK'' x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ c_CasADi__explicitRK_TIC_TIC x0' x1' >>= (newForeignPtr c_delete_CasADi__FX) >>= wrapReturn++foreign import ccall unsafe "CasADi__explicitRK_TIC_TIC_TIC" c_CasADi__explicitRK_TIC_TIC_TIC+ :: Ptr FX' -> IO (Ptr FX')+explicitRK'''+ :: FX -> IO FX+explicitRK''' x0 =+ withMarshal x0 $ \x0' ->+ c_CasADi__explicitRK_TIC_TIC_TIC x0' >>= (newForeignPtr c_delete_CasADi__FX) >>= wrapReturn+
+ LICENSE view
@@ -0,0 +1,165 @@+ GNU LESSER GENERAL PUBLIC LICENSE+ Version 3, 29 June 2007++ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>+ Everyone is permitted to copy and distribute verbatim copies+ of this license document, but changing it is not allowed.+++ This version of the GNU Lesser General Public License incorporates+the terms and conditions of version 3 of the GNU General Public+License, supplemented by the additional permissions listed below.++ 0. Additional Definitions. ++ As used herein, "this License" refers to version 3 of the GNU Lesser+General Public License, and the "GNU GPL" refers to version 3 of the GNU+General Public License.++ "The Library" refers to a covered work governed by this License,+other than an Application or a Combined Work as defined below.++ An "Application" is any work that makes use of an interface provided+by the Library, but which is not otherwise based on the Library.+Defining a subclass of a class defined by the Library is deemed a mode+of using an interface provided by the Library.++ A "Combined Work" is a work produced by combining or linking an+Application with the Library. The particular version of the Library+with which the Combined Work was made is also called the "Linked+Version".++ The "Minimal Corresponding Source" for a Combined Work means the+Corresponding Source for the Combined Work, excluding any source code+for portions of the Combined Work that, considered in isolation, are+based on the Application, and not on the Linked Version.++ The "Corresponding Application Code" for a Combined Work means the+object code and/or source code for the Application, including any data+and utility programs needed for reproducing the Combined Work from the+Application, but excluding the System Libraries of the Combined Work.++ 1. Exception to Section 3 of the GNU GPL.++ You may convey a covered work under sections 3 and 4 of this License+without being bound by section 3 of the GNU GPL.++ 2. Conveying Modified Versions.++ If you modify a copy of the Library, and, in your modifications, a+facility refers to a function or data to be supplied by an Application+that uses the facility (other than as an argument passed when the+facility is invoked), then you may convey a copy of the modified+version:++ a) under this License, provided that you make a good faith effort to+ ensure that, in the event an Application does not supply the+ function or data, the facility still operates, and performs+ whatever part of its purpose remains meaningful, or++ b) under the GNU GPL, with none of the additional permissions of+ this License applicable to that copy.++ 3. Object Code Incorporating Material from Library Header Files.++ The object code form of an Application may incorporate material from+a header file that is part of the Library. You may convey such object+code under terms of your choice, provided that, if the incorporated+material is not limited to numerical parameters, data structure+layouts and accessors, or small macros, inline functions and templates+(ten or fewer lines in length), you do both of the following:++ a) Give prominent notice with each copy of the object code that the+ Library is used in it and that the Library and its use are+ covered by this License.++ b) Accompany the object code with a copy of the GNU GPL and this license+ document.++ 4. Combined Works.++ You may convey a Combined Work under terms of your choice that,+taken together, effectively do not restrict modification of the+portions of the Library contained in the Combined Work and reverse+engineering for debugging such modifications, if you also do each of+the following:++ a) Give prominent notice with each copy of the Combined Work that+ the Library is used in it and that the Library and its use are+ covered by this License.++ b) Accompany the Combined Work with a copy of the GNU GPL and this license+ document.++ c) For a Combined Work that displays copyright notices during+ execution, include the copyright notice for the Library among+ these notices, as well as a reference directing the user to the+ copies of the GNU GPL and this license document.++ d) Do one of the following:++ 0) Convey the Minimal Corresponding Source under the terms of this+ License, and the Corresponding Application Code in a form+ suitable for, and under terms that permit, the user to+ recombine or relink the Application with a modified version of+ the Linked Version to produce a modified Combined Work, in the+ manner specified by section 6 of the GNU GPL for conveying+ Corresponding Source.++ 1) Use a suitable shared library mechanism for linking with the+ Library. A suitable mechanism is one that (a) uses at run time+ a copy of the Library already present on the user's computer+ system, and (b) will operate properly with a modified version+ of the Library that is interface-compatible with the Linked+ Version. ++ e) Provide Installation Information, but only if you would otherwise+ be required to provide such information under section 6 of the+ GNU GPL, and only to the extent that such information is+ necessary to install and execute a modified version of the+ Combined Work produced by recombining or relinking the+ Application with a modified version of the Linked Version. (If+ you use option 4d0, the Installation Information must accompany+ the Minimal Corresponding Source and Corresponding Application+ Code. If you use option 4d1, you must provide the Installation+ Information in the manner specified by section 6 of the GNU GPL+ for conveying Corresponding Source.)++ 5. Combined Libraries.++ You may place library facilities that are a work based on the+Library side by side in a single library together with other library+facilities that are not Applications and are not covered by this+License, and convey such a combined library under terms of your+choice, if you do both of the following:++ a) Accompany the combined library with a copy of the same work based+ on the Library, uncombined with any other library facilities,+ conveyed under the terms of this License.++ b) Give prominent notice with the combined library that part of it+ is a work based on the Library, and explaining where to find the+ accompanying uncombined form of the same work.++ 6. Revised Versions of the GNU Lesser General Public License.++ The Free Software Foundation may publish revised and/or new versions+of the GNU Lesser General Public License from time to time. Such new+versions will be similar in spirit to the present version, but may+differ in detail to address new problems or concerns.++ Each version is given a distinguishing version number. If the+Library as you received it specifies that a certain numbered version+of the GNU Lesser General Public License "or any later version"+applies to it, you have the option of following the terms and+conditions either of that published version or of any later version+published by the Free Software Foundation. If the Library as you+received it does not specify a version number of the GNU Lesser+General Public License, you may choose any version of the GNU Lesser+General Public License ever published by the Free Software Foundation.++ If the Library as you received it specifies that a proxy can decide+whether future versions of the GNU Lesser General Public License shall+apply, that proxy's public statement of acceptance of any version is+permanent authorization for you to choose that version for the+Library.
+ Setup.hs view
@@ -0,0 +1,2 @@+import Distribution.Simple+main = defaultMainWithHooks simpleUserHooks
+ casadi-bindings.cabal view
@@ -0,0 +1,97 @@+name: casadi-bindings+version: 1.8.0.0+synopsis: low level bindings to CasADi+description: See the readme on github for installation instructions. Version numbers correspond to the C++ library version numbers. This only works on Debian/Ubuntu at the moment (sorry).+license: LGPL-3+license-file: LICENSE+copyright: (c) 2013-2014 Greg Horn+author: Greg Horn+maintainer: gregmainland@gmail.com+build-type: Simple+cabal-version: >=1.10++extra-source-files: cbits/marshal.hpp+extra-tmp-files: Casadi/Callback_stub.h++library+ build-depends: base >=4.6 && <5, vector >=0.10++ default-language: Haskell2010++ Include-dirs: /usr/include/casadi+ /usr/share/casadi++ extra-lib-dirs: /usr/lib+ extra-libraries: stdc+++ casadi_ipopt_interface+ casadi_ipopt+ dl+ casadi_coinmumps+ pthread+ casadi_coinlapack+ casadi_coinmetis+ casadi_coinblas+ gfortran+ m+ gcc_s+ quadmath+ casadi_sundials_interface+ casadi_sundials+ casadi_csparse_interface+ casadi_csparse+ casadi_optimal_control+ casadi_control+ casadi_tinyxml+ casadi_integration+ casadi_convex_programming+ casadi_nonlinear_programming+ casadi+ dl+-- /usr/lib/x86_64-linux-gnu/librt.so++ ghc-prof-options: -O2 -prof -fprof-auto -fprof-cafs -rtsopts+ ghc-options: -O2+ cc-options: -O2 -Wall -Wno-delete-non-virtual-dtor++ C-sources: cbits/hs_tools.cpp+ cbits/callback.cpp+ cbits/autogen/all.cpp++ other-modules: Casadi.Marshal+ Casadi.MarshalTypes+ Casadi.WrapReturn+ Casadi.Wrappers.ForeignToolsImports+ Casadi.Wrappers.ForeignToolsInstances+ Casadi.Wrappers.Data+ Casadi.Wrappers.Deleters++ exposed-modules: Casadi.Callback+ Casadi.Wrappers.Tools+ Casadi.Wrappers.Enums+ Casadi.Wrappers.Classes.SXFunction+ Casadi.Wrappers.Classes.MXFunction+ Casadi.Wrappers.Classes.FX+ Casadi.Wrappers.Classes.SharedObject+ Casadi.Wrappers.Classes.PrintableObject+ Casadi.Wrappers.Classes.CRSSparsity+ Casadi.Wrappers.Classes.GenericType+ Casadi.Wrappers.Classes.IOInterfaceFX+ Casadi.Wrappers.Classes.OptionsFunctionality+ Casadi.Wrappers.Classes.IpoptSolver+ Casadi.Wrappers.Classes.SXMatrix+ Casadi.Wrappers.Classes.IOScheme+ Casadi.Wrappers.Classes.DMatrix+ Casadi.Wrappers.Classes.MX+ Casadi.Wrappers.Classes.CasadiOptions+ Casadi.Wrappers.Classes.Callback+ Casadi.Wrappers.Classes.CustomEvaluate+ Casadi.Wrappers.Classes.ExternalFunction+ Casadi.Wrappers.Classes.CSparse+ Casadi.Wrappers.Classes.SX+ Casadi.Wrappers.Classes.CasadiMeta+ Casadi.Wrappers.Classes.Functor+ Casadi.Wrappers.Classes.CustomFunction++source-repository head+ type: git+ location: git://github.com/ghorn/casadi-bindings.git
+ cbits/autogen/all.cpp view
@@ -0,0 +1,22239 @@+#include <swiginclude.hpp>+#include "../marshal.hpp"+#include <symbolic/functor_internal.hpp>+#include <symbolic/fx/custom_function.hpp>+// ================== delete CasadiClass SXFunction===============+// classType: CasadiClass SXFunction+extern "C"+ void delete_CasADi__SXFunction(CasADi::SXFunction* obj);+void delete_CasADi__SXFunction(CasADi::SXFunction* obj){+ delete obj;+}+extern "C"+ void delete_std__vector_CasADi__SXFunction_(std::vector<CasADi::SXFunction* >* obj);+void delete_std__vector_CasADi__SXFunction_(std::vector<CasADi::SXFunction* >* obj){+ delete obj;+}+extern "C"+ void delete_std__vector_std__vector_CasADi__SXFunction__(std::vector<std::vector<CasADi::SXFunction* > >* obj);+void delete_std__vector_std__vector_CasADi__SXFunction__(std::vector<std::vector<CasADi::SXFunction* > >* obj){+ delete obj;+}+extern "C"+ void delete_std__vector_std__vector_std__vector_CasADi__SXFunction___(std::vector<std::vector<std::vector<CasADi::SXFunction* > > >* obj);+void delete_std__vector_std__vector_std__vector_CasADi__SXFunction___(std::vector<std::vector<std::vector<CasADi::SXFunction* > > >* obj){+ delete obj;+}++// ================== Normal method: "jac" ===============+// class: "CasADi::SXFunction"+// cppName: "CasADi::SXFunction::jac"+// cWrapperName: "CasADi__SXFunction__jac"+// protoArgs: "(CasADi::SXFunction* obj, int x0, int x1, bool* x2, bool* x3)"+// args: "(x0_, x1_, x2_, x3_)"+// rettype: Val (NonVec (CasadiClass SXMatrix))+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__SXFunction__jac(CasADi::SXFunction* obj, int x0, int x1, bool* x2, bool* x3)"+// call: "obj->jac(x0_, x1_, x2_, x3_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__SXFunction__jac(CasADi::SXFunction* obj, int x0, int x1, bool* x2, bool* x3);+CasADi::Matrix< CasADi::SX >* CasADi__SXFunction__jac(CasADi::SXFunction* obj, int x0, int x1, bool* x2, bool* x3){+ int x0_ = Marshaling<int,int>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);+ bool x2_ = Marshaling<bool,bool*>::marshal(x2);+ bool x3_ = Marshaling<bool,bool*>::marshal(x3);++ return new CasADi::Matrix< CasADi::SX >( obj->jac(x0_, x1_, x2_, x3_) );+}+++// ================== Normal method: "grad" ===============+// class: "CasADi::SXFunction"+// cppName: "CasADi::SXFunction::grad"+// cWrapperName: "CasADi__SXFunction__grad"+// protoArgs: "(CasADi::SXFunction* obj, int x0, int x1)"+// args: "(x0_, x1_)"+// rettype: Val (NonVec (CasadiClass SXMatrix))+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__SXFunction__grad(CasADi::SXFunction* obj, int x0, int x1)"+// call: "obj->grad(x0_, x1_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__SXFunction__grad(CasADi::SXFunction* obj, int x0, int x1);+CasADi::Matrix< CasADi::SX >* CasADi__SXFunction__grad(CasADi::SXFunction* obj, int x0, int x1){+ int x0_ = Marshaling<int,int>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);++ return new CasADi::Matrix< CasADi::SX >( obj->grad(x0_, x1_) );+}+++// ================== Normal method: "hess" ===============+// class: "CasADi::SXFunction"+// cppName: "CasADi::SXFunction::hess"+// cWrapperName: "CasADi__SXFunction__hess"+// protoArgs: "(CasADi::SXFunction* obj, int x0, int x1)"+// args: "(x0_, x1_)"+// rettype: Val (NonVec (CasadiClass SXMatrix))+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__SXFunction__hess(CasADi::SXFunction* obj, int x0, int x1)"+// call: "obj->hess(x0_, x1_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__SXFunction__hess(CasADi::SXFunction* obj, int x0, int x1);+CasADi::Matrix< CasADi::SX >* CasADi__SXFunction__hess(CasADi::SXFunction* obj, int x0, int x1){+ int x0_ = Marshaling<int,int>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);++ return new CasADi::Matrix< CasADi::SX >( obj->hess(x0_, x1_) );+}+++// ================== Normal method: "getAlgorithmSize" ===============+// class: "CasADi::SXFunction"+// cppName: "CasADi::SXFunction::getAlgorithmSize"+// cWrapperName: "CasADi__SXFunction__getAlgorithmSize"+// protoArgs: "(CasADi::SXFunction* obj)"+// args: "()"+// rettype: Val (NonVec CInt)+// cWrapperRetType: "int"+// proto: "int CasADi__SXFunction__getAlgorithmSize(CasADi::SXFunction* obj)"+// call: "obj->getAlgorithmSize()"+extern "C"+ int CasADi__SXFunction__getAlgorithmSize(CasADi::SXFunction* obj);+int CasADi__SXFunction__getAlgorithmSize(CasADi::SXFunction* obj){++ return obj->getAlgorithmSize();+}+++// ================== Normal method: "getWorkSize" ===============+// class: "CasADi::SXFunction"+// cppName: "CasADi::SXFunction::getWorkSize"+// cWrapperName: "CasADi__SXFunction__getWorkSize"+// protoArgs: "(CasADi::SXFunction* obj)"+// args: "()"+// rettype: Val (NonVec CInt)+// cWrapperRetType: "int"+// proto: "int CasADi__SXFunction__getWorkSize(CasADi::SXFunction* obj)"+// call: "obj->getWorkSize()"+extern "C"+ int CasADi__SXFunction__getWorkSize(CasADi::SXFunction* obj);+int CasADi__SXFunction__getWorkSize(CasADi::SXFunction* obj){++ return obj->getWorkSize();+}+++// ================== Normal method: "getAtomicOperation" ===============+// class: "CasADi::SXFunction"+// cppName: "CasADi::SXFunction::getAtomicOperation"+// cWrapperName: "CasADi__SXFunction__getAtomicOperation"+// protoArgs: "(CasADi::SXFunction* obj, int x0)"+// args: "(x0_)"+// rettype: Val (NonVec CInt)+// cWrapperRetType: "int"+// proto: "int CasADi__SXFunction__getAtomicOperation(CasADi::SXFunction* obj, int x0)"+// call: "obj->getAtomicOperation(x0_)"+extern "C"+ int CasADi__SXFunction__getAtomicOperation(CasADi::SXFunction* obj, int x0);+int CasADi__SXFunction__getAtomicOperation(CasADi::SXFunction* obj, int x0){+ int x0_ = Marshaling<int,int>::marshal(x0);++ return obj->getAtomicOperation(x0_);+}+++// ================== Normal method: "getAtomicInputReal" ===============+// class: "CasADi::SXFunction"+// cppName: "CasADi::SXFunction::getAtomicInputReal"+// cWrapperName: "CasADi__SXFunction__getAtomicInputReal"+// protoArgs: "(CasADi::SXFunction* obj, int x0)"+// args: "(x0_)"+// rettype: Val (NonVec CDouble)+// cWrapperRetType: "double"+// proto: "double CasADi__SXFunction__getAtomicInputReal(CasADi::SXFunction* obj, int x0)"+// call: "obj->getAtomicInputReal(x0_)"+extern "C"+ double CasADi__SXFunction__getAtomicInputReal(CasADi::SXFunction* obj, int x0);+double CasADi__SXFunction__getAtomicInputReal(CasADi::SXFunction* obj, int x0){+ int x0_ = Marshaling<int,int>::marshal(x0);++ return obj->getAtomicInputReal(x0_);+}+++// ================== Normal method: "getAtomicOutput" ===============+// class: "CasADi::SXFunction"+// cppName: "CasADi::SXFunction::getAtomicOutput"+// cWrapperName: "CasADi__SXFunction__getAtomicOutput"+// protoArgs: "(CasADi::SXFunction* obj, int x0)"+// args: "(x0_)"+// rettype: Val (NonVec CInt)+// cWrapperRetType: "int"+// proto: "int CasADi__SXFunction__getAtomicOutput(CasADi::SXFunction* obj, int x0)"+// call: "obj->getAtomicOutput(x0_)"+extern "C"+ int CasADi__SXFunction__getAtomicOutput(CasADi::SXFunction* obj, int x0);+int CasADi__SXFunction__getAtomicOutput(CasADi::SXFunction* obj, int x0){+ int x0_ = Marshaling<int,int>::marshal(x0);++ return obj->getAtomicOutput(x0_);+}+++// ================== Normal method: "countNodes" ===============+// class: "CasADi::SXFunction"+// cppName: "CasADi::SXFunction::countNodes"+// cWrapperName: "CasADi__SXFunction__countNodes"+// protoArgs: "(CasADi::SXFunction* obj)"+// args: "()"+// rettype: Val (NonVec CInt)+// cWrapperRetType: "int"+// proto: "int CasADi__SXFunction__countNodes(CasADi::SXFunction* obj)"+// call: "obj->countNodes()"+extern "C"+ int CasADi__SXFunction__countNodes(CasADi::SXFunction* obj);+int CasADi__SXFunction__countNodes(CasADi::SXFunction* obj){++ return obj->countNodes();+}+++// ================== Normal method: "getFree" ===============+// class: "CasADi::SXFunction"+// cppName: "CasADi::SXFunction::getFree"+// cWrapperName: "CasADi__SXFunction__getFree"+// protoArgs: "(CasADi::SXFunction* obj)"+// args: "()"+// rettype: Val (Vec (NonVec (CasadiClass SX)))+// cWrapperRetType: "std::vector<CasADi::SX >*"+// proto: "std::vector<CasADi::SX >* CasADi__SXFunction__getFree(CasADi::SXFunction* obj)"+// call: "obj->getFree()"+extern "C"+ std::vector<CasADi::SX >* CasADi__SXFunction__getFree(CasADi::SXFunction* obj);+std::vector<CasADi::SX >* CasADi__SXFunction__getFree(CasADi::SXFunction* obj){++ return new std::vector<CasADi::SX >( obj->getFree() );+}+++// ================== Normal method: "indexed_one_based" ===============+// class: "CasADi::SXFunction"+// cppName: "CasADi::SXFunction::indexed_one_based"+// cWrapperName: "CasADi__SXFunction__indexed_one_based"+// protoArgs: "(CasADi::SXFunction* obj, int x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass SXFunction))+// cWrapperRetType: "CasADi::SXFunction*"+// proto: "CasADi::SXFunction* CasADi__SXFunction__indexed_one_based(CasADi::SXFunction* obj, int x0)"+// call: "obj->indexed_one_based(x0_)"+extern "C"+ CasADi::SXFunction* CasADi__SXFunction__indexed_one_based(CasADi::SXFunction* obj, int x0);+CasADi::SXFunction* CasADi__SXFunction__indexed_one_based(CasADi::SXFunction* obj, int x0){+ int x0_ = Marshaling<int,int>::marshal(x0);++ return new CasADi::SXFunction( obj->indexed_one_based(x0_) );+}+++// ================== Normal method: "indexed_zero_based" ===============+// class: "CasADi::SXFunction"+// cppName: "CasADi::SXFunction::indexed_zero_based"+// cWrapperName: "CasADi__SXFunction__indexed_zero_based"+// protoArgs: "(CasADi::SXFunction* obj, int x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass SXFunction))+// cWrapperRetType: "CasADi::SXFunction*"+// proto: "CasADi::SXFunction* CasADi__SXFunction__indexed_zero_based(CasADi::SXFunction* obj, int x0)"+// call: "obj->indexed_zero_based(x0_)"+extern "C"+ CasADi::SXFunction* CasADi__SXFunction__indexed_zero_based(CasADi::SXFunction* obj, int x0);+CasADi::SXFunction* CasADi__SXFunction__indexed_zero_based(CasADi::SXFunction* obj, int x0){+ int x0_ = Marshaling<int,int>::marshal(x0);++ return new CasADi::SXFunction( obj->indexed_zero_based(x0_) );+}+++// ================== Constructor method: "SXFunction'" ===============+// class: "CasADi::SXFunction"+// cppName: "CasADi::SXFunction"+// cWrapperName: "CasADi__SXFunction__SXFunction_TIC"+// protoArgs: "(CasADi::MXFunction* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass SXFunction))+// cWrapperRetType: "CasADi::SXFunction*"+// proto: "CasADi::SXFunction* CasADi__SXFunction__SXFunction_TIC(CasADi::MXFunction* x0)"+// call: "CasADi::SXFunction(x0_)"+extern "C"+ CasADi::SXFunction* CasADi__SXFunction__SXFunction_TIC(CasADi::MXFunction* x0);+CasADi::SXFunction* CasADi__SXFunction__SXFunction_TIC(CasADi::MXFunction* x0){+ CasADi::MXFunction x0_ = Marshaling<CasADi::MXFunction,CasADi::MXFunction*>::marshal(x0);++ return new CasADi::SXFunction( CasADi::SXFunction(x0_) );+}+++// ================== Constructor method: "SXFunction''" ===============+// class: "CasADi::SXFunction"+// cppName: "CasADi::SXFunction"+// cWrapperName: "CasADi__SXFunction__SXFunction_TIC_TIC"+// protoArgs: "(CasADi::FX* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass SXFunction))+// cWrapperRetType: "CasADi::SXFunction*"+// proto: "CasADi::SXFunction* CasADi__SXFunction__SXFunction_TIC_TIC(CasADi::FX* x0)"+// call: "CasADi::SXFunction(x0_)"+extern "C"+ CasADi::SXFunction* CasADi__SXFunction__SXFunction_TIC_TIC(CasADi::FX* x0);+CasADi::SXFunction* CasADi__SXFunction__SXFunction_TIC_TIC(CasADi::FX* x0){+ CasADi::FX x0_ = Marshaling<CasADi::FX,CasADi::FX*>::marshal(x0);++ return new CasADi::SXFunction( CasADi::SXFunction(x0_) );+}+++// ================== Constructor method: "SXFunction'''" ===============+// class: "CasADi::SXFunction"+// cppName: "CasADi::SXFunction"+// cWrapperName: "CasADi__SXFunction__SXFunction_TIC_TIC_TIC"+// protoArgs: "(std::vector<CasADi::Matrix< CasADi::SX >* > * x0, std::vector<CasADi::Matrix< CasADi::SX >* > * x1)"+// args: "(x0_, x1_)"+// rettype: Val (NonVec (CasadiClass SXFunction))+// cWrapperRetType: "CasADi::SXFunction*"+// proto: "CasADi::SXFunction* CasADi__SXFunction__SXFunction_TIC_TIC_TIC(std::vector<CasADi::Matrix< CasADi::SX >* > * x0, std::vector<CasADi::Matrix< CasADi::SX >* > * x1)"+// call: "CasADi::SXFunction(x0_, x1_)"+extern "C"+ CasADi::SXFunction* CasADi__SXFunction__SXFunction_TIC_TIC_TIC(std::vector<CasADi::Matrix< CasADi::SX >* > * x0, std::vector<CasADi::Matrix< CasADi::SX >* > * x1);+CasADi::SXFunction* CasADi__SXFunction__SXFunction_TIC_TIC_TIC(std::vector<CasADi::Matrix< CasADi::SX >* > * x0, std::vector<CasADi::Matrix< CasADi::SX >* > * x1){+ std::vector<CasADi::Matrix< CasADi::SX > > x0_ = Marshaling<std::vector<CasADi::Matrix< CasADi::SX > >,std::vector<CasADi::Matrix< CasADi::SX >* > *>::marshal(x0);+ std::vector<CasADi::Matrix< CasADi::SX > > x1_ = Marshaling<std::vector<CasADi::Matrix< CasADi::SX > >,std::vector<CasADi::Matrix< CasADi::SX >* > *>::marshal(x1);++ return new CasADi::SXFunction( CasADi::SXFunction(x0_, x1_) );+}+++// ================== delete CasadiClass MXFunction===============+// classType: CasadiClass MXFunction+extern "C"+ void delete_CasADi__MXFunction(CasADi::MXFunction* obj);+void delete_CasADi__MXFunction(CasADi::MXFunction* obj){+ delete obj;+}+extern "C"+ void delete_std__vector_CasADi__MXFunction_(std::vector<CasADi::MXFunction* >* obj);+void delete_std__vector_CasADi__MXFunction_(std::vector<CasADi::MXFunction* >* obj){+ delete obj;+}+extern "C"+ void delete_std__vector_std__vector_CasADi__MXFunction__(std::vector<std::vector<CasADi::MXFunction* > >* obj);+void delete_std__vector_std__vector_CasADi__MXFunction__(std::vector<std::vector<CasADi::MXFunction* > >* obj){+ delete obj;+}+extern "C"+ void delete_std__vector_std__vector_std__vector_CasADi__MXFunction___(std::vector<std::vector<std::vector<CasADi::MXFunction* > > >* obj);+void delete_std__vector_std__vector_std__vector_CasADi__MXFunction___(std::vector<std::vector<std::vector<CasADi::MXFunction* > > >* obj){+ delete obj;+}++// ================== Normal method: "getAlgorithmSize" ===============+// class: "CasADi::MXFunction"+// cppName: "CasADi::MXFunction::getAlgorithmSize"+// cWrapperName: "CasADi__MXFunction__getAlgorithmSize"+// protoArgs: "(CasADi::MXFunction* obj)"+// args: "()"+// rettype: Val (NonVec CInt)+// cWrapperRetType: "int"+// proto: "int CasADi__MXFunction__getAlgorithmSize(CasADi::MXFunction* obj)"+// call: "obj->getAlgorithmSize()"+extern "C"+ int CasADi__MXFunction__getAlgorithmSize(CasADi::MXFunction* obj);+int CasADi__MXFunction__getAlgorithmSize(CasADi::MXFunction* obj){++ return obj->getAlgorithmSize();+}+++// ================== Normal method: "getWorkSize" ===============+// class: "CasADi::MXFunction"+// cppName: "CasADi::MXFunction::getWorkSize"+// cWrapperName: "CasADi__MXFunction__getWorkSize"+// protoArgs: "(CasADi::MXFunction* obj)"+// args: "()"+// rettype: Val (NonVec CInt)+// cWrapperRetType: "int"+// proto: "int CasADi__MXFunction__getWorkSize(CasADi::MXFunction* obj)"+// call: "obj->getWorkSize()"+extern "C"+ int CasADi__MXFunction__getWorkSize(CasADi::MXFunction* obj);+int CasADi__MXFunction__getWorkSize(CasADi::MXFunction* obj){++ return obj->getWorkSize();+}+++// ================== Normal method: "countNodes" ===============+// class: "CasADi::MXFunction"+// cppName: "CasADi::MXFunction::countNodes"+// cWrapperName: "CasADi__MXFunction__countNodes"+// protoArgs: "(CasADi::MXFunction* obj)"+// args: "()"+// rettype: Val (NonVec CInt)+// cWrapperRetType: "int"+// proto: "int CasADi__MXFunction__countNodes(CasADi::MXFunction* obj)"+// call: "obj->countNodes()"+extern "C"+ int CasADi__MXFunction__countNodes(CasADi::MXFunction* obj);+int CasADi__MXFunction__countNodes(CasADi::MXFunction* obj){++ return obj->countNodes();+}+++// ================== Normal method: "checkNode" ===============+// class: "CasADi::MXFunction"+// cppName: "CasADi::MXFunction::checkNode"+// cWrapperName: "CasADi__MXFunction__checkNode"+// protoArgs: "(CasADi::MXFunction* obj)"+// args: "()"+// rettype: Val (NonVec CBool)+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__MXFunction__checkNode(CasADi::MXFunction* obj)"+// call: "obj->checkNode()"+extern "C"+ bool* CasADi__MXFunction__checkNode(CasADi::MXFunction* obj);+bool* CasADi__MXFunction__checkNode(CasADi::MXFunction* obj){++ return new bool( obj->checkNode() );+}+++// ================== Normal method: "jac" ===============+// class: "CasADi::MXFunction"+// cppName: "CasADi::MXFunction::jac"+// cWrapperName: "CasADi__MXFunction__jac"+// protoArgs: "(CasADi::MXFunction* obj, int x0, int x1, bool* x2, bool* x3)"+// args: "(x0_, x1_, x2_, x3_)"+// rettype: Val (NonVec (CasadiClass MX))+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__MXFunction__jac(CasADi::MXFunction* obj, int x0, int x1, bool* x2, bool* x3)"+// call: "obj->jac(x0_, x1_, x2_, x3_)"+extern "C"+ CasADi::MX* CasADi__MXFunction__jac(CasADi::MXFunction* obj, int x0, int x1, bool* x2, bool* x3);+CasADi::MX* CasADi__MXFunction__jac(CasADi::MXFunction* obj, int x0, int x1, bool* x2, bool* x3){+ int x0_ = Marshaling<int,int>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);+ bool x2_ = Marshaling<bool,bool*>::marshal(x2);+ bool x3_ = Marshaling<bool,bool*>::marshal(x3);++ return new CasADi::MX( obj->jac(x0_, x1_, x2_, x3_) );+}+++// ================== Normal method: "grad" ===============+// class: "CasADi::MXFunction"+// cppName: "CasADi::MXFunction::grad"+// cWrapperName: "CasADi__MXFunction__grad"+// protoArgs: "(CasADi::MXFunction* obj, int x0, int x1)"+// args: "(x0_, x1_)"+// rettype: Val (NonVec (CasadiClass MX))+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__MXFunction__grad(CasADi::MXFunction* obj, int x0, int x1)"+// call: "obj->grad(x0_, x1_)"+extern "C"+ CasADi::MX* CasADi__MXFunction__grad(CasADi::MXFunction* obj, int x0, int x1);+CasADi::MX* CasADi__MXFunction__grad(CasADi::MXFunction* obj, int x0, int x1){+ int x0_ = Marshaling<int,int>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);++ return new CasADi::MX( obj->grad(x0_, x1_) );+}+++// ================== Normal method: "getFree" ===============+// class: "CasADi::MXFunction"+// cppName: "CasADi::MXFunction::getFree"+// cWrapperName: "CasADi__MXFunction__getFree"+// protoArgs: "(CasADi::MXFunction* obj)"+// args: "()"+// rettype: Val (Vec (NonVec (CasadiClass MX)))+// cWrapperRetType: "std::vector<CasADi::MX >*"+// proto: "std::vector<CasADi::MX >* CasADi__MXFunction__getFree(CasADi::MXFunction* obj)"+// call: "obj->getFree()"+extern "C"+ std::vector<CasADi::MX >* CasADi__MXFunction__getFree(CasADi::MXFunction* obj);+std::vector<CasADi::MX >* CasADi__MXFunction__getFree(CasADi::MXFunction* obj){++ return new std::vector<CasADi::MX >( obj->getFree() );+}+++// ================== Normal method: "generateLiftingFunctions" ===============+// class: "CasADi::MXFunction"+// cppName: "CasADi::MXFunction::generateLiftingFunctions"+// cWrapperName: "CasADi__MXFunction__generateLiftingFunctions"+// protoArgs: "(CasADi::MXFunction* obj, CasADi::MXFunction* x0, CasADi::MXFunction* x1)"+// args: "(x0_, x1_)"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__MXFunction__generateLiftingFunctions(CasADi::MXFunction* obj, CasADi::MXFunction* x0, CasADi::MXFunction* x1)"+// call: "obj->generateLiftingFunctions(x0_, x1_)"+extern "C"+ void CasADi__MXFunction__generateLiftingFunctions(CasADi::MXFunction* obj, CasADi::MXFunction* x0, CasADi::MXFunction* x1);+void CasADi__MXFunction__generateLiftingFunctions(CasADi::MXFunction* obj, CasADi::MXFunction* x0, CasADi::MXFunction* x1){+ CasADi::MXFunction x0_ = Marshaling<CasADi::MXFunction,CasADi::MXFunction*>::marshal(x0);+ CasADi::MXFunction x1_ = Marshaling<CasADi::MXFunction,CasADi::MXFunction*>::marshal(x1);++ return obj->generateLiftingFunctions(x0_, x1_);+}+++// ================== Constructor method: "MXFunction'" ===============+// class: "CasADi::MXFunction"+// cppName: "CasADi::MXFunction"+// cWrapperName: "CasADi__MXFunction__MXFunction_TIC"+// protoArgs: "(CasADi::FX* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass MXFunction))+// cWrapperRetType: "CasADi::MXFunction*"+// proto: "CasADi::MXFunction* CasADi__MXFunction__MXFunction_TIC(CasADi::FX* x0)"+// call: "CasADi::MXFunction(x0_)"+extern "C"+ CasADi::MXFunction* CasADi__MXFunction__MXFunction_TIC(CasADi::FX* x0);+CasADi::MXFunction* CasADi__MXFunction__MXFunction_TIC(CasADi::FX* x0){+ CasADi::FX x0_ = Marshaling<CasADi::FX,CasADi::FX*>::marshal(x0);++ return new CasADi::MXFunction( CasADi::MXFunction(x0_) );+}+++// ================== Constructor method: "MXFunction" ===============+// class: "CasADi::MXFunction"+// cppName: "CasADi::MXFunction"+// cWrapperName: "CasADi__MXFunction__MXFunction"+// protoArgs: "(std::vector<CasADi::MX* > * x0, std::vector<CasADi::MX* > * x1)"+// args: "(x0_, x1_)"+// rettype: Val (NonVec (CasadiClass MXFunction))+// cWrapperRetType: "CasADi::MXFunction*"+// proto: "CasADi::MXFunction* CasADi__MXFunction__MXFunction(std::vector<CasADi::MX* > * x0, std::vector<CasADi::MX* > * x1)"+// call: "CasADi::MXFunction(x0_, x1_)"+extern "C"+ CasADi::MXFunction* CasADi__MXFunction__MXFunction(std::vector<CasADi::MX* > * x0, std::vector<CasADi::MX* > * x1);+CasADi::MXFunction* CasADi__MXFunction__MXFunction(std::vector<CasADi::MX* > * x0, std::vector<CasADi::MX* > * x1){+ std::vector<CasADi::MX > x0_ = Marshaling<std::vector<CasADi::MX >,std::vector<CasADi::MX* > *>::marshal(x0);+ std::vector<CasADi::MX > x1_ = Marshaling<std::vector<CasADi::MX >,std::vector<CasADi::MX* > *>::marshal(x1);++ return new CasADi::MXFunction( CasADi::MXFunction(x0_, x1_) );+}+++// ================== delete CasadiClass FX===============+// classType: CasadiClass FX+extern "C"+ void delete_CasADi__FX(CasADi::FX* obj);+void delete_CasADi__FX(CasADi::FX* obj){+ delete obj;+}+extern "C"+ void delete_std__vector_CasADi__FX_(std::vector<CasADi::FX* >* obj);+void delete_std__vector_CasADi__FX_(std::vector<CasADi::FX* >* obj){+ delete obj;+}+extern "C"+ void delete_std__vector_std__vector_CasADi__FX__(std::vector<std::vector<CasADi::FX* > >* obj);+void delete_std__vector_std__vector_CasADi__FX__(std::vector<std::vector<CasADi::FX* > >* obj){+ delete obj;+}+extern "C"+ void delete_std__vector_std__vector_std__vector_CasADi__FX___(std::vector<std::vector<std::vector<CasADi::FX* > > >* obj);+void delete_std__vector_std__vector_std__vector_CasADi__FX___(std::vector<std::vector<std::vector<CasADi::FX* > > >* obj){+ delete obj;+}++// ================== Normal method: "inputScheme" ===============+// class: "CasADi::FX"+// cppName: "CasADi::FX::inputScheme"+// cWrapperName: "CasADi__FX__inputScheme"+// protoArgs: "(CasADi::FX* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass IOScheme))+// cWrapperRetType: "CasADi::IOScheme*"+// proto: "CasADi::IOScheme* CasADi__FX__inputScheme(CasADi::FX* obj)"+// call: "obj->inputScheme()"+extern "C"+ CasADi::IOScheme* CasADi__FX__inputScheme(CasADi::FX* obj);+CasADi::IOScheme* CasADi__FX__inputScheme(CasADi::FX* obj){++ return new CasADi::IOScheme( obj->inputScheme() );+}+++// ================== Normal method: "outputScheme" ===============+// class: "CasADi::FX"+// cppName: "CasADi::FX::outputScheme"+// cWrapperName: "CasADi__FX__outputScheme"+// protoArgs: "(CasADi::FX* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass IOScheme))+// cWrapperRetType: "CasADi::IOScheme*"+// proto: "CasADi::IOScheme* CasADi__FX__outputScheme(CasADi::FX* obj)"+// call: "obj->outputScheme()"+extern "C"+ CasADi::IOScheme* CasADi__FX__outputScheme(CasADi::FX* obj);+CasADi::IOScheme* CasADi__FX__outputScheme(CasADi::FX* obj){++ return new CasADi::IOScheme( obj->outputScheme() );+}+++// ================== Normal method: "setInputScheme" ===============+// class: "CasADi::FX"+// cppName: "CasADi::FX::setInputScheme"+// cWrapperName: "CasADi__FX__setInputScheme"+// protoArgs: "(CasADi::FX* obj, CasADi::IOScheme* x0)"+// args: "(x0_)"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__FX__setInputScheme(CasADi::FX* obj, CasADi::IOScheme* x0)"+// call: "obj->setInputScheme(x0_)"+extern "C"+ void CasADi__FX__setInputScheme(CasADi::FX* obj, CasADi::IOScheme* x0);+void CasADi__FX__setInputScheme(CasADi::FX* obj, CasADi::IOScheme* x0){+ CasADi::IOScheme x0_ = Marshaling<CasADi::IOScheme,CasADi::IOScheme*>::marshal(x0);++ return obj->setInputScheme(x0_);+}+++// ================== Normal method: "setOutputScheme" ===============+// class: "CasADi::FX"+// cppName: "CasADi::FX::setOutputScheme"+// cWrapperName: "CasADi__FX__setOutputScheme"+// protoArgs: "(CasADi::FX* obj, CasADi::IOScheme* x0)"+// args: "(x0_)"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__FX__setOutputScheme(CasADi::FX* obj, CasADi::IOScheme* x0)"+// call: "obj->setOutputScheme(x0_)"+extern "C"+ void CasADi__FX__setOutputScheme(CasADi::FX* obj, CasADi::IOScheme* x0);+void CasADi__FX__setOutputScheme(CasADi::FX* obj, CasADi::IOScheme* x0){+ CasADi::IOScheme x0_ = Marshaling<CasADi::IOScheme,CasADi::IOScheme*>::marshal(x0);++ return obj->setOutputScheme(x0_);+}+++// ================== Normal method: "getInputScheme" ===============+// class: "CasADi::FX"+// cppName: "CasADi::FX::getInputScheme"+// cWrapperName: "CasADi__FX__getInputScheme"+// protoArgs: "(CasADi::FX* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass IOScheme))+// cWrapperRetType: "CasADi::IOScheme*"+// proto: "CasADi::IOScheme* CasADi__FX__getInputScheme(CasADi::FX* obj)"+// call: "obj->getInputScheme()"+extern "C"+ CasADi::IOScheme* CasADi__FX__getInputScheme(CasADi::FX* obj);+CasADi::IOScheme* CasADi__FX__getInputScheme(CasADi::FX* obj){++ return new CasADi::IOScheme( obj->getInputScheme() );+}+++// ================== Normal method: "getOutputScheme" ===============+// class: "CasADi::FX"+// cppName: "CasADi::FX::getOutputScheme"+// cWrapperName: "CasADi__FX__getOutputScheme"+// protoArgs: "(CasADi::FX* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass IOScheme))+// cWrapperRetType: "CasADi::IOScheme*"+// proto: "CasADi::IOScheme* CasADi__FX__getOutputScheme(CasADi::FX* obj)"+// call: "obj->getOutputScheme()"+extern "C"+ CasADi::IOScheme* CasADi__FX__getOutputScheme(CasADi::FX* obj);+CasADi::IOScheme* CasADi__FX__getOutputScheme(CasADi::FX* obj){++ return new CasADi::IOScheme( obj->getOutputScheme() );+}+++// ================== Normal method: "evaluate" ===============+// class: "CasADi::FX"+// cppName: "CasADi::FX::evaluate"+// cWrapperName: "CasADi__FX__evaluate"+// protoArgs: "(CasADi::FX* obj)"+// args: "()"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__FX__evaluate(CasADi::FX* obj)"+// call: "obj->evaluate()"+extern "C"+ void CasADi__FX__evaluate(CasADi::FX* obj);+void CasADi__FX__evaluate(CasADi::FX* obj){++ return obj->evaluate();+}+++// ================== Normal method: "solve" ===============+// class: "CasADi::FX"+// cppName: "CasADi::FX::solve"+// cWrapperName: "CasADi__FX__solve"+// protoArgs: "(CasADi::FX* obj)"+// args: "()"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__FX__solve(CasADi::FX* obj)"+// call: "obj->solve()"+extern "C"+ void CasADi__FX__solve(CasADi::FX* obj);+void CasADi__FX__solve(CasADi::FX* obj){++ return obj->solve();+}+++// ================== Normal method: "jacobian" ===============+// class: "CasADi::FX"+// cppName: "CasADi::FX::jacobian"+// cWrapperName: "CasADi__FX__jacobian"+// protoArgs: "(CasADi::FX* obj, int x0, int x1, bool* x2, bool* x3)"+// args: "(x0_, x1_, x2_, x3_)"+// rettype: Val (NonVec (CasadiClass FX))+// cWrapperRetType: "CasADi::FX*"+// proto: "CasADi::FX* CasADi__FX__jacobian(CasADi::FX* obj, int x0, int x1, bool* x2, bool* x3)"+// call: "obj->jacobian(x0_, x1_, x2_, x3_)"+extern "C"+ CasADi::FX* CasADi__FX__jacobian(CasADi::FX* obj, int x0, int x1, bool* x2, bool* x3);+CasADi::FX* CasADi__FX__jacobian(CasADi::FX* obj, int x0, int x1, bool* x2, bool* x3){+ int x0_ = Marshaling<int,int>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);+ bool x2_ = Marshaling<bool,bool*>::marshal(x2);+ bool x3_ = Marshaling<bool,bool*>::marshal(x3);++ return new CasADi::FX( obj->jacobian(x0_, x1_, x2_, x3_) );+}+++// ================== Normal method: "gradient" ===============+// class: "CasADi::FX"+// cppName: "CasADi::FX::gradient"+// cWrapperName: "CasADi__FX__gradient"+// protoArgs: "(CasADi::FX* obj, int x0, int x1)"+// args: "(x0_, x1_)"+// rettype: Val (NonVec (CasadiClass FX))+// cWrapperRetType: "CasADi::FX*"+// proto: "CasADi::FX* CasADi__FX__gradient(CasADi::FX* obj, int x0, int x1)"+// call: "obj->gradient(x0_, x1_)"+extern "C"+ CasADi::FX* CasADi__FX__gradient(CasADi::FX* obj, int x0, int x1);+CasADi::FX* CasADi__FX__gradient(CasADi::FX* obj, int x0, int x1){+ int x0_ = Marshaling<int,int>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);++ return new CasADi::FX( obj->gradient(x0_, x1_) );+}+++// ================== Normal method: "hessian" ===============+// class: "CasADi::FX"+// cppName: "CasADi::FX::hessian"+// cWrapperName: "CasADi__FX__hessian"+// protoArgs: "(CasADi::FX* obj, int x0, int x1)"+// args: "(x0_, x1_)"+// rettype: Val (NonVec (CasadiClass FX))+// cWrapperRetType: "CasADi::FX*"+// proto: "CasADi::FX* CasADi__FX__hessian(CasADi::FX* obj, int x0, int x1)"+// call: "obj->hessian(x0_, x1_)"+extern "C"+ CasADi::FX* CasADi__FX__hessian(CasADi::FX* obj, int x0, int x1);+CasADi::FX* CasADi__FX__hessian(CasADi::FX* obj, int x0, int x1){+ int x0_ = Marshaling<int,int>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);++ return new CasADi::FX( obj->hessian(x0_, x1_) );+}+++// ================== Normal method: "fullJacobian" ===============+// class: "CasADi::FX"+// cppName: "CasADi::FX::fullJacobian"+// cWrapperName: "CasADi__FX__fullJacobian"+// protoArgs: "(CasADi::FX* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass FX))+// cWrapperRetType: "CasADi::FX*"+// proto: "CasADi::FX* CasADi__FX__fullJacobian(CasADi::FX* obj)"+// call: "obj->fullJacobian()"+extern "C"+ CasADi::FX* CasADi__FX__fullJacobian(CasADi::FX* obj);+CasADi::FX* CasADi__FX__fullJacobian(CasADi::FX* obj){++ return new CasADi::FX( obj->fullJacobian() );+}+++// ================== Normal method: "call" ===============+// class: "CasADi::FX"+// cppName: "CasADi::FX::call"+// cWrapperName: "CasADi__FX__call"+// protoArgs: "(CasADi::FX* obj, std::vector<CasADi::MX* > * x0)"+// args: "(x0_)"+// rettype: Val (Vec (NonVec (CasadiClass MX)))+// cWrapperRetType: "std::vector<CasADi::MX >*"+// proto: "std::vector<CasADi::MX >* CasADi__FX__call(CasADi::FX* obj, std::vector<CasADi::MX* > * x0)"+// call: "obj->call(x0_)"+extern "C"+ std::vector<CasADi::MX >* CasADi__FX__call(CasADi::FX* obj, std::vector<CasADi::MX* > * x0);+std::vector<CasADi::MX >* CasADi__FX__call(CasADi::FX* obj, std::vector<CasADi::MX* > * x0){+ std::vector<CasADi::MX > x0_ = Marshaling<std::vector<CasADi::MX >,std::vector<CasADi::MX* > *>::marshal(x0);++ return new std::vector<CasADi::MX >( obj->call(x0_) );+}+++// ================== Normal method: "call''" ===============+// class: "CasADi::FX"+// cppName: "CasADi::FX::call''"+// cWrapperName: "CasADi__FX__call_TIC_TIC"+// protoArgs: "(CasADi::FX* obj, std::vector<std::vector<CasADi::MX* > > * x0)"+// args: "(x0_)"+// rettype: Val (Vec (Vec (NonVec (CasadiClass MX))))+// cWrapperRetType: "std::vector<std::vector<CasADi::MX > >*"+// proto: "std::vector<std::vector<CasADi::MX > >* CasADi__FX__call_TIC_TIC(CasADi::FX* obj, std::vector<std::vector<CasADi::MX* > > * x0)"+// call: "obj->call(x0_)"+extern "C"+ std::vector<std::vector<CasADi::MX > >* CasADi__FX__call_TIC_TIC(CasADi::FX* obj, std::vector<std::vector<CasADi::MX* > > * x0);+std::vector<std::vector<CasADi::MX > >* CasADi__FX__call_TIC_TIC(CasADi::FX* obj, std::vector<std::vector<CasADi::MX* > > * x0){+ std::vector<std::vector<CasADi::MX > > x0_ = Marshaling<std::vector<std::vector<CasADi::MX > >,std::vector<std::vector<CasADi::MX* > > *>::marshal(x0);++ return new std::vector<std::vector<CasADi::MX > >( obj->call(x0_) );+}+++// ================== Normal method: "evalMX" ===============+// class: "CasADi::FX"+// cppName: "CasADi::FX::evalMX"+// cWrapperName: "CasADi__FX__evalMX"+// protoArgs: "(CasADi::FX* obj, std::vector<CasADi::MX* > * x0)"+// args: "(x0_)"+// rettype: Val (Vec (NonVec (CasadiClass MX)))+// cWrapperRetType: "std::vector<CasADi::MX >*"+// proto: "std::vector<CasADi::MX >* CasADi__FX__evalMX(CasADi::FX* obj, std::vector<CasADi::MX* > * x0)"+// call: "obj->evalMX(x0_)"+extern "C"+ std::vector<CasADi::MX >* CasADi__FX__evalMX(CasADi::FX* obj, std::vector<CasADi::MX* > * x0);+std::vector<CasADi::MX >* CasADi__FX__evalMX(CasADi::FX* obj, std::vector<CasADi::MX* > * x0){+ std::vector<CasADi::MX > x0_ = Marshaling<std::vector<CasADi::MX >,std::vector<CasADi::MX* > *>::marshal(x0);++ return new std::vector<CasADi::MX >( obj->evalMX(x0_) );+}+++// ================== Normal method: "evalSX" ===============+// class: "CasADi::FX"+// cppName: "CasADi::FX::evalSX"+// cWrapperName: "CasADi__FX__evalSX"+// protoArgs: "(CasADi::FX* obj, std::vector<CasADi::Matrix< CasADi::SX >* > * x0)"+// args: "(x0_)"+// rettype: Val (Vec (NonVec (CasadiClass SXMatrix)))+// cWrapperRetType: "std::vector<CasADi::Matrix< CasADi::SX > >*"+// proto: "std::vector<CasADi::Matrix< CasADi::SX > >* CasADi__FX__evalSX(CasADi::FX* obj, std::vector<CasADi::Matrix< CasADi::SX >* > * x0)"+// call: "obj->evalSX(x0_)"+extern "C"+ std::vector<CasADi::Matrix< CasADi::SX > >* CasADi__FX__evalSX(CasADi::FX* obj, std::vector<CasADi::Matrix< CasADi::SX >* > * x0);+std::vector<CasADi::Matrix< CasADi::SX > >* CasADi__FX__evalSX(CasADi::FX* obj, std::vector<CasADi::Matrix< CasADi::SX >* > * x0){+ std::vector<CasADi::Matrix< CasADi::SX > > x0_ = Marshaling<std::vector<CasADi::Matrix< CasADi::SX > >,std::vector<CasADi::Matrix< CasADi::SX >* > *>::marshal(x0);++ return new std::vector<CasADi::Matrix< CasADi::SX > >( obj->evalSX(x0_) );+}+++// ================== Normal method: "generateCode" ===============+// class: "CasADi::FX"+// cppName: "CasADi::FX::generateCode"+// cWrapperName: "CasADi__FX__generateCode"+// protoArgs: "(CasADi::FX* obj, std::string* x0)"+// args: "(x0_)"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__FX__generateCode(CasADi::FX* obj, std::string* x0)"+// call: "obj->generateCode(x0_)"+extern "C"+ void CasADi__FX__generateCode(CasADi::FX* obj, std::string* x0);+void CasADi__FX__generateCode(CasADi::FX* obj, std::string* x0){+ std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);++ return obj->generateCode(x0_);+}+++// ================== Normal method: "checkNode" ===============+// class: "CasADi::FX"+// cppName: "CasADi::FX::checkNode"+// cWrapperName: "CasADi__FX__checkNode"+// protoArgs: "(CasADi::FX* obj)"+// args: "()"+// rettype: Val (NonVec CBool)+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__FX__checkNode(CasADi::FX* obj)"+// call: "obj->checkNode()"+extern "C"+ bool* CasADi__FX__checkNode(CasADi::FX* obj);+bool* CasADi__FX__checkNode(CasADi::FX* obj){++ return new bool( obj->checkNode() );+}+++// ================== Normal method: "getStat" ===============+// class: "CasADi::FX"+// cppName: "CasADi::FX::getStat"+// cWrapperName: "CasADi__FX__getStat"+// protoArgs: "(CasADi::FX* obj, std::string* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass GenericType))+// cWrapperRetType: "CasADi::GenericType*"+// proto: "CasADi::GenericType* CasADi__FX__getStat(CasADi::FX* obj, std::string* x0)"+// call: "obj->getStat(x0_)"+extern "C"+ CasADi::GenericType* CasADi__FX__getStat(CasADi::FX* obj, std::string* x0);+CasADi::GenericType* CasADi__FX__getStat(CasADi::FX* obj, std::string* x0){+ std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);++ return new CasADi::GenericType( obj->getStat(x0_) );+}+++// ================== Normal method: "symbolicInput" ===============+// class: "CasADi::FX"+// cppName: "CasADi::FX::symbolicInput"+// cWrapperName: "CasADi__FX__symbolicInput"+// protoArgs: "(CasADi::FX* obj)"+// args: "()"+// rettype: Val (Vec (NonVec (CasadiClass MX)))+// cWrapperRetType: "std::vector<CasADi::MX >*"+// proto: "std::vector<CasADi::MX >* CasADi__FX__symbolicInput(CasADi::FX* obj)"+// call: "obj->symbolicInput()"+extern "C"+ std::vector<CasADi::MX >* CasADi__FX__symbolicInput(CasADi::FX* obj);+std::vector<CasADi::MX >* CasADi__FX__symbolicInput(CasADi::FX* obj){++ return new std::vector<CasADi::MX >( obj->symbolicInput() );+}+++// ================== Normal method: "symbolicInputSX" ===============+// class: "CasADi::FX"+// cppName: "CasADi::FX::symbolicInputSX"+// cWrapperName: "CasADi__FX__symbolicInputSX"+// protoArgs: "(CasADi::FX* obj)"+// args: "()"+// rettype: Val (Vec (NonVec (CasadiClass SXMatrix)))+// cWrapperRetType: "std::vector<CasADi::Matrix< CasADi::SX > >*"+// proto: "std::vector<CasADi::Matrix< CasADi::SX > >* CasADi__FX__symbolicInputSX(CasADi::FX* obj)"+// call: "obj->symbolicInputSX()"+extern "C"+ std::vector<CasADi::Matrix< CasADi::SX > >* CasADi__FX__symbolicInputSX(CasADi::FX* obj);+std::vector<CasADi::Matrix< CasADi::SX > >* CasADi__FX__symbolicInputSX(CasADi::FX* obj){++ return new std::vector<CasADi::Matrix< CasADi::SX > >( obj->symbolicInputSX() );+}+++// ================== Normal method: "addMonitor" ===============+// class: "CasADi::FX"+// cppName: "CasADi::FX::addMonitor"+// cWrapperName: "CasADi__FX__addMonitor"+// protoArgs: "(CasADi::FX* obj, std::string* x0)"+// args: "(x0_)"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__FX__addMonitor(CasADi::FX* obj, std::string* x0)"+// call: "obj->addMonitor(x0_)"+extern "C"+ void CasADi__FX__addMonitor(CasADi::FX* obj, std::string* x0);+void CasADi__FX__addMonitor(CasADi::FX* obj, std::string* x0){+ std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);++ return obj->addMonitor(x0_);+}+++// ================== Normal method: "removeMonitor" ===============+// class: "CasADi::FX"+// cppName: "CasADi::FX::removeMonitor"+// cWrapperName: "CasADi__FX__removeMonitor"+// protoArgs: "(CasADi::FX* obj, std::string* x0)"+// args: "(x0_)"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__FX__removeMonitor(CasADi::FX* obj, std::string* x0)"+// call: "obj->removeMonitor(x0_)"+extern "C"+ void CasADi__FX__removeMonitor(CasADi::FX* obj, std::string* x0);+void CasADi__FX__removeMonitor(CasADi::FX* obj, std::string* x0){+ std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);++ return obj->removeMonitor(x0_);+}+++// ================== Normal method: "checkInputs" ===============+// class: "CasADi::FX"+// cppName: "CasADi::FX::checkInputs"+// cWrapperName: "CasADi__FX__checkInputs"+// protoArgs: "(CasADi::FX* obj)"+// args: "()"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__FX__checkInputs(CasADi::FX* obj)"+// call: "obj->checkInputs()"+extern "C"+ void CasADi__FX__checkInputs(CasADi::FX* obj);+void CasADi__FX__checkInputs(CasADi::FX* obj){++ return obj->checkInputs();+}+++// ================== delete CasadiClass SharedObject===============+// classType: CasadiClass SharedObject+extern "C"+ void delete_CasADi__SharedObject(CasADi::SharedObject* obj);+void delete_CasADi__SharedObject(CasADi::SharedObject* obj){+ delete obj;+}+extern "C"+ void delete_std__vector_CasADi__SharedObject_(std::vector<CasADi::SharedObject* >* obj);+void delete_std__vector_CasADi__SharedObject_(std::vector<CasADi::SharedObject* >* obj){+ delete obj;+}+extern "C"+ void delete_std__vector_std__vector_CasADi__SharedObject__(std::vector<std::vector<CasADi::SharedObject* > >* obj);+void delete_std__vector_std__vector_CasADi__SharedObject__(std::vector<std::vector<CasADi::SharedObject* > >* obj){+ delete obj;+}+extern "C"+ void delete_std__vector_std__vector_std__vector_CasADi__SharedObject___(std::vector<std::vector<std::vector<CasADi::SharedObject* > > >* obj);+void delete_std__vector_std__vector_std__vector_CasADi__SharedObject___(std::vector<std::vector<std::vector<CasADi::SharedObject* > > >* obj){+ delete obj;+}++// ================== Normal method: "printPtr'" ===============+// class: "CasADi::SharedObject"+// cppName: "CasADi::SharedObject::printPtr'"+// cWrapperName: "CasADi__SharedObject__printPtr_TIC"+// protoArgs: "(CasADi::SharedObject* obj)"+// args: "()"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__SharedObject__printPtr_TIC(CasADi::SharedObject* obj)"+// call: "obj->printPtr()"+extern "C"+ void CasADi__SharedObject__printPtr_TIC(CasADi::SharedObject* obj);+void CasADi__SharedObject__printPtr_TIC(CasADi::SharedObject* obj){++ return obj->printPtr();+}+++// ================== Normal method: "init" ===============+// class: "CasADi::SharedObject"+// cppName: "CasADi::SharedObject::init"+// cWrapperName: "CasADi__SharedObject__init"+// protoArgs: "(CasADi::SharedObject* obj)"+// args: "()"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__SharedObject__init(CasADi::SharedObject* obj)"+// call: "obj->init()"+extern "C"+ void CasADi__SharedObject__init(CasADi::SharedObject* obj);+void CasADi__SharedObject__init(CasADi::SharedObject* obj){++ return obj->init();+}+++// ================== Normal method: "isInit" ===============+// class: "CasADi::SharedObject"+// cppName: "CasADi::SharedObject::isInit"+// cWrapperName: "CasADi__SharedObject__isInit"+// protoArgs: "(CasADi::SharedObject* obj)"+// args: "()"+// rettype: Val (NonVec CBool)+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__SharedObject__isInit(CasADi::SharedObject* obj)"+// call: "obj->isInit()"+extern "C"+ bool* CasADi__SharedObject__isInit(CasADi::SharedObject* obj);+bool* CasADi__SharedObject__isInit(CasADi::SharedObject* obj){++ return new bool( obj->isInit() );+}+++// ================== Normal method: "assertInit" ===============+// class: "CasADi::SharedObject"+// cppName: "CasADi::SharedObject::assertInit"+// cWrapperName: "CasADi__SharedObject__assertInit"+// protoArgs: "(CasADi::SharedObject* obj)"+// args: "()"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__SharedObject__assertInit(CasADi::SharedObject* obj)"+// call: "obj->assertInit()"+extern "C"+ void CasADi__SharedObject__assertInit(CasADi::SharedObject* obj);+void CasADi__SharedObject__assertInit(CasADi::SharedObject* obj){++ return obj->assertInit();+}+++// ================== Normal method: "checkNode" ===============+// class: "CasADi::SharedObject"+// cppName: "CasADi::SharedObject::checkNode"+// cWrapperName: "CasADi__SharedObject__checkNode"+// protoArgs: "(CasADi::SharedObject* obj)"+// args: "()"+// rettype: Val (NonVec CBool)+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__SharedObject__checkNode(CasADi::SharedObject* obj)"+// call: "obj->checkNode()"+extern "C"+ bool* CasADi__SharedObject__checkNode(CasADi::SharedObject* obj);+bool* CasADi__SharedObject__checkNode(CasADi::SharedObject* obj){++ return new bool( obj->checkNode() );+}+++// ================== Normal method: "makeUnique" ===============+// class: "CasADi::SharedObject"+// cppName: "CasADi::SharedObject::makeUnique"+// cWrapperName: "CasADi__SharedObject__makeUnique"+// protoArgs: "(CasADi::SharedObject* obj, bool* x0)"+// args: "(x0_)"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__SharedObject__makeUnique(CasADi::SharedObject* obj, bool* x0)"+// call: "obj->makeUnique(x0_)"+extern "C"+ void CasADi__SharedObject__makeUnique(CasADi::SharedObject* obj, bool* x0);+void CasADi__SharedObject__makeUnique(CasADi::SharedObject* obj, bool* x0){+ bool x0_ = Marshaling<bool,bool*>::marshal(x0);++ return obj->makeUnique(x0_);+}+++// ================== Normal method: "makeUnique'" ===============+// class: "CasADi::SharedObject"+// cppName: "CasADi::SharedObject::makeUnique'"+// cWrapperName: "CasADi__SharedObject__makeUnique_TIC"+// protoArgs: "(CasADi::SharedObject* obj)"+// args: "()"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__SharedObject__makeUnique_TIC(CasADi::SharedObject* obj)"+// call: "obj->makeUnique()"+extern "C"+ void CasADi__SharedObject__makeUnique_TIC(CasADi::SharedObject* obj);+void CasADi__SharedObject__makeUnique_TIC(CasADi::SharedObject* obj){++ return obj->makeUnique();+}+++// ================== delete CasadiClass PrintableObject===============+// classType: CasadiClass PrintableObject+extern "C"+ void delete_CasADi__PrintableObject(CasADi::PrintableObject* obj);+void delete_CasADi__PrintableObject(CasADi::PrintableObject* obj){+ delete obj;+}+extern "C"+ void delete_std__vector_CasADi__PrintableObject_(std::vector<CasADi::PrintableObject* >* obj);+void delete_std__vector_CasADi__PrintableObject_(std::vector<CasADi::PrintableObject* >* obj){+ delete obj;+}+extern "C"+ void delete_std__vector_std__vector_CasADi__PrintableObject__(std::vector<std::vector<CasADi::PrintableObject* > >* obj);+void delete_std__vector_std__vector_CasADi__PrintableObject__(std::vector<std::vector<CasADi::PrintableObject* > >* obj){+ delete obj;+}+extern "C"+ void delete_std__vector_std__vector_std__vector_CasADi__PrintableObject___(std::vector<std::vector<std::vector<CasADi::PrintableObject* > > >* obj);+void delete_std__vector_std__vector_std__vector_CasADi__PrintableObject___(std::vector<std::vector<std::vector<CasADi::PrintableObject* > > >* obj){+ delete obj;+}++// ================== Normal method: "getRepresentation" ===============+// class: "CasADi::PrintableObject"+// cppName: "CasADi::PrintableObject::getRepresentation"+// cWrapperName: "CasADi__PrintableObject__getRepresentation"+// protoArgs: "(CasADi::PrintableObject* obj)"+// args: "()"+// rettype: Val (NonVec StdString)+// cWrapperRetType: "std::string*"+// proto: "std::string* CasADi__PrintableObject__getRepresentation(CasADi::PrintableObject* obj)"+// call: "obj->getRepresentation()"+extern "C"+ std::string* CasADi__PrintableObject__getRepresentation(CasADi::PrintableObject* obj);+std::string* CasADi__PrintableObject__getRepresentation(CasADi::PrintableObject* obj){++ return new std::string( obj->getRepresentation() );+}+++// ================== Normal method: "getDescription" ===============+// class: "CasADi::PrintableObject"+// cppName: "CasADi::PrintableObject::getDescription"+// cWrapperName: "CasADi__PrintableObject__getDescription"+// protoArgs: "(CasADi::PrintableObject* obj)"+// args: "()"+// rettype: Val (NonVec StdString)+// cWrapperRetType: "std::string*"+// proto: "std::string* CasADi__PrintableObject__getDescription(CasADi::PrintableObject* obj)"+// call: "obj->getDescription()"+extern "C"+ std::string* CasADi__PrintableObject__getDescription(CasADi::PrintableObject* obj);+std::string* CasADi__PrintableObject__getDescription(CasADi::PrintableObject* obj){++ return new std::string( obj->getDescription() );+}+++// ================== delete CasadiClass CRSSparsity===============+// classType: CasadiClass CRSSparsity+extern "C"+ void delete_CasADi__CRSSparsity(CasADi::CRSSparsity* obj);+void delete_CasADi__CRSSparsity(CasADi::CRSSparsity* obj){+ delete obj;+}+extern "C"+ void delete_std__vector_CasADi__CRSSparsity_(std::vector<CasADi::CRSSparsity* >* obj);+void delete_std__vector_CasADi__CRSSparsity_(std::vector<CasADi::CRSSparsity* >* obj){+ delete obj;+}+extern "C"+ void delete_std__vector_std__vector_CasADi__CRSSparsity__(std::vector<std::vector<CasADi::CRSSparsity* > >* obj);+void delete_std__vector_std__vector_CasADi__CRSSparsity__(std::vector<std::vector<CasADi::CRSSparsity* > >* obj){+ delete obj;+}+extern "C"+ void delete_std__vector_std__vector_std__vector_CasADi__CRSSparsity___(std::vector<std::vector<std::vector<CasADi::CRSSparsity* > > >* obj);+void delete_std__vector_std__vector_std__vector_CasADi__CRSSparsity___(std::vector<std::vector<std::vector<CasADi::CRSSparsity* > > >* obj){+ delete obj;+}++// ================== Normal method: "size1" ===============+// class: "CasADi::CRSSparsity"+// cppName: "CasADi::CRSSparsity::size1"+// cWrapperName: "CasADi__CRSSparsity__size1"+// protoArgs: "(CasADi::CRSSparsity* obj)"+// args: "()"+// rettype: Val (NonVec CInt)+// cWrapperRetType: "int"+// proto: "int CasADi__CRSSparsity__size1(CasADi::CRSSparsity* obj)"+// call: "obj->size1()"+extern "C"+ int CasADi__CRSSparsity__size1(CasADi::CRSSparsity* obj);+int CasADi__CRSSparsity__size1(CasADi::CRSSparsity* obj){++ return obj->size1();+}+++// ================== Normal method: "size2" ===============+// class: "CasADi::CRSSparsity"+// cppName: "CasADi::CRSSparsity::size2"+// cWrapperName: "CasADi__CRSSparsity__size2"+// protoArgs: "(CasADi::CRSSparsity* obj)"+// args: "()"+// rettype: Val (NonVec CInt)+// cWrapperRetType: "int"+// proto: "int CasADi__CRSSparsity__size2(CasADi::CRSSparsity* obj)"+// call: "obj->size2()"+extern "C"+ int CasADi__CRSSparsity__size2(CasADi::CRSSparsity* obj);+int CasADi__CRSSparsity__size2(CasADi::CRSSparsity* obj){++ return obj->size2();+}+++// ================== Normal method: "numel" ===============+// class: "CasADi::CRSSparsity"+// cppName: "CasADi::CRSSparsity::numel"+// cWrapperName: "CasADi__CRSSparsity__numel"+// protoArgs: "(CasADi::CRSSparsity* obj)"+// args: "()"+// rettype: Val (NonVec CInt)+// cWrapperRetType: "int"+// proto: "int CasADi__CRSSparsity__numel(CasADi::CRSSparsity* obj)"+// call: "obj->numel()"+extern "C"+ int CasADi__CRSSparsity__numel(CasADi::CRSSparsity* obj);+int CasADi__CRSSparsity__numel(CasADi::CRSSparsity* obj){++ return obj->numel();+}+++// ================== Normal method: "empty" ===============+// class: "CasADi::CRSSparsity"+// cppName: "CasADi::CRSSparsity::empty"+// cWrapperName: "CasADi__CRSSparsity__empty"+// protoArgs: "(CasADi::CRSSparsity* obj)"+// args: "()"+// rettype: Val (NonVec CBool)+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__CRSSparsity__empty(CasADi::CRSSparsity* obj)"+// call: "obj->empty()"+extern "C"+ bool* CasADi__CRSSparsity__empty(CasADi::CRSSparsity* obj);+bool* CasADi__CRSSparsity__empty(CasADi::CRSSparsity* obj){++ return new bool( obj->empty() );+}+++// ================== Normal method: "null" ===============+// class: "CasADi::CRSSparsity"+// cppName: "CasADi::CRSSparsity::null"+// cWrapperName: "CasADi__CRSSparsity__null"+// protoArgs: "(CasADi::CRSSparsity* obj)"+// args: "()"+// rettype: Val (NonVec CBool)+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__CRSSparsity__null(CasADi::CRSSparsity* obj)"+// call: "obj->null()"+extern "C"+ bool* CasADi__CRSSparsity__null(CasADi::CRSSparsity* obj);+bool* CasADi__CRSSparsity__null(CasADi::CRSSparsity* obj){++ return new bool( obj->null() );+}+++// ================== Normal method: "size" ===============+// class: "CasADi::CRSSparsity"+// cppName: "CasADi::CRSSparsity::size"+// cWrapperName: "CasADi__CRSSparsity__size"+// protoArgs: "(CasADi::CRSSparsity* obj)"+// args: "()"+// rettype: Val (NonVec CInt)+// cWrapperRetType: "int"+// proto: "int CasADi__CRSSparsity__size(CasADi::CRSSparsity* obj)"+// call: "obj->size()"+extern "C"+ int CasADi__CRSSparsity__size(CasADi::CRSSparsity* obj);+int CasADi__CRSSparsity__size(CasADi::CRSSparsity* obj){++ return obj->size();+}+++// ================== Normal method: "sizeU" ===============+// class: "CasADi::CRSSparsity"+// cppName: "CasADi::CRSSparsity::sizeU"+// cWrapperName: "CasADi__CRSSparsity__sizeU"+// protoArgs: "(CasADi::CRSSparsity* obj)"+// args: "()"+// rettype: Val (NonVec CInt)+// cWrapperRetType: "int"+// proto: "int CasADi__CRSSparsity__sizeU(CasADi::CRSSparsity* obj)"+// call: "obj->sizeU()"+extern "C"+ int CasADi__CRSSparsity__sizeU(CasADi::CRSSparsity* obj);+int CasADi__CRSSparsity__sizeU(CasADi::CRSSparsity* obj){++ return obj->sizeU();+}+++// ================== Normal method: "sizeL" ===============+// class: "CasADi::CRSSparsity"+// cppName: "CasADi::CRSSparsity::sizeL"+// cWrapperName: "CasADi__CRSSparsity__sizeL"+// protoArgs: "(CasADi::CRSSparsity* obj)"+// args: "()"+// rettype: Val (NonVec CInt)+// cWrapperRetType: "int"+// proto: "int CasADi__CRSSparsity__sizeL(CasADi::CRSSparsity* obj)"+// call: "obj->sizeL()"+extern "C"+ int CasADi__CRSSparsity__sizeL(CasADi::CRSSparsity* obj);+int CasADi__CRSSparsity__sizeL(CasADi::CRSSparsity* obj){++ return obj->sizeL();+}+++// ================== Normal method: "sizeD" ===============+// class: "CasADi::CRSSparsity"+// cppName: "CasADi::CRSSparsity::sizeD"+// cWrapperName: "CasADi__CRSSparsity__sizeD"+// protoArgs: "(CasADi::CRSSparsity* obj)"+// args: "()"+// rettype: Val (NonVec CInt)+// cWrapperRetType: "int"+// proto: "int CasADi__CRSSparsity__sizeD(CasADi::CRSSparsity* obj)"+// call: "obj->sizeD()"+extern "C"+ int CasADi__CRSSparsity__sizeD(CasADi::CRSSparsity* obj);+int CasADi__CRSSparsity__sizeD(CasADi::CRSSparsity* obj){++ return obj->sizeD();+}+++// ================== Normal method: "col" ===============+// class: "CasADi::CRSSparsity"+// cppName: "CasADi::CRSSparsity::col"+// cWrapperName: "CasADi__CRSSparsity__col"+// protoArgs: "(CasADi::CRSSparsity* obj, int x0)"+// args: "(x0_)"+// rettype: Val (NonVec CInt)+// cWrapperRetType: "int"+// proto: "int CasADi__CRSSparsity__col(CasADi::CRSSparsity* obj, int x0)"+// call: "obj->col(x0_)"+extern "C"+ int CasADi__CRSSparsity__col(CasADi::CRSSparsity* obj, int x0);+int CasADi__CRSSparsity__col(CasADi::CRSSparsity* obj, int x0){+ int x0_ = Marshaling<int,int>::marshal(x0);++ return obj->col(x0_);+}+++// ================== Normal method: "rowind" ===============+// class: "CasADi::CRSSparsity"+// cppName: "CasADi::CRSSparsity::rowind"+// cWrapperName: "CasADi__CRSSparsity__rowind"+// protoArgs: "(CasADi::CRSSparsity* obj, int x0)"+// args: "(x0_)"+// rettype: Val (NonVec CInt)+// cWrapperRetType: "int"+// proto: "int CasADi__CRSSparsity__rowind(CasADi::CRSSparsity* obj, int x0)"+// call: "obj->rowind(x0_)"+extern "C"+ int CasADi__CRSSparsity__rowind(CasADi::CRSSparsity* obj, int x0);+int CasADi__CRSSparsity__rowind(CasADi::CRSSparsity* obj, int x0){+ int x0_ = Marshaling<int,int>::marshal(x0);++ return obj->rowind(x0_);+}+++// ================== Normal method: "colRef" ===============+// class: "CasADi::CRSSparsity"+// cppName: "CasADi::CRSSparsity::colRef"+// cWrapperName: "CasADi__CRSSparsity__colRef"+// protoArgs: "(CasADi::CRSSparsity* obj)"+// args: "()"+// rettype: Val (Vec (NonVec CInt))+// cWrapperRetType: "std::vector<int >*"+// proto: "std::vector<int >* CasADi__CRSSparsity__colRef(CasADi::CRSSparsity* obj)"+// call: "obj->colRef()"+extern "C"+ std::vector<int >* CasADi__CRSSparsity__colRef(CasADi::CRSSparsity* obj);+std::vector<int >* CasADi__CRSSparsity__colRef(CasADi::CRSSparsity* obj){++ return new std::vector<int >( obj->colRef() );+}+++// ================== Normal method: "rowindRef" ===============+// class: "CasADi::CRSSparsity"+// cppName: "CasADi::CRSSparsity::rowindRef"+// cWrapperName: "CasADi__CRSSparsity__rowindRef"+// protoArgs: "(CasADi::CRSSparsity* obj)"+// args: "()"+// rettype: Val (Vec (NonVec CInt))+// cWrapperRetType: "std::vector<int >*"+// proto: "std::vector<int >* CasADi__CRSSparsity__rowindRef(CasADi::CRSSparsity* obj)"+// call: "obj->rowindRef()"+extern "C"+ std::vector<int >* CasADi__CRSSparsity__rowindRef(CasADi::CRSSparsity* obj);+std::vector<int >* CasADi__CRSSparsity__rowindRef(CasADi::CRSSparsity* obj){++ return new std::vector<int >( obj->rowindRef() );+}+++// ================== Normal method: "getRow" ===============+// class: "CasADi::CRSSparsity"+// cppName: "CasADi::CRSSparsity::getRow"+// cWrapperName: "CasADi__CRSSparsity__getRow"+// protoArgs: "(CasADi::CRSSparsity* obj)"+// args: "()"+// rettype: Val (Vec (NonVec CInt))+// cWrapperRetType: "std::vector<int >*"+// proto: "std::vector<int >* CasADi__CRSSparsity__getRow(CasADi::CRSSparsity* obj)"+// call: "obj->getRow()"+extern "C"+ std::vector<int >* CasADi__CRSSparsity__getRow(CasADi::CRSSparsity* obj);+std::vector<int >* CasADi__CRSSparsity__getRow(CasADi::CRSSparsity* obj){++ return new std::vector<int >( obj->getRow() );+}+++// ================== Normal method: "getNZ" ===============+// class: "CasADi::CRSSparsity"+// cppName: "CasADi::CRSSparsity::getNZ"+// cWrapperName: "CasADi__CRSSparsity__getNZ"+// protoArgs: "(CasADi::CRSSparsity* obj, int x0, int x1)"+// args: "(x0_, x1_)"+// rettype: Val (NonVec CInt)+// cWrapperRetType: "int"+// proto: "int CasADi__CRSSparsity__getNZ(CasADi::CRSSparsity* obj, int x0, int x1)"+// call: "obj->getNZ(x0_, x1_)"+extern "C"+ int CasADi__CRSSparsity__getNZ(CasADi::CRSSparsity* obj, int x0, int x1);+int CasADi__CRSSparsity__getNZ(CasADi::CRSSparsity* obj, int x0, int x1){+ int x0_ = Marshaling<int,int>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);++ return obj->getNZ(x0_, x1_);+}+++// ================== Normal method: "getNZ''" ===============+// class: "CasADi::CRSSparsity"+// cppName: "CasADi::CRSSparsity::getNZ''"+// cWrapperName: "CasADi__CRSSparsity__getNZ_TIC_TIC"+// protoArgs: "(CasADi::CRSSparsity* obj, std::vector<int > * x0, std::vector<int > * x1)"+// args: "(x0_, x1_)"+// rettype: Val (Vec (NonVec CInt))+// cWrapperRetType: "std::vector<int >*"+// proto: "std::vector<int >* CasADi__CRSSparsity__getNZ_TIC_TIC(CasADi::CRSSparsity* obj, std::vector<int > * x0, std::vector<int > * x1)"+// call: "obj->getNZ(x0_, x1_)"+extern "C"+ std::vector<int >* CasADi__CRSSparsity__getNZ_TIC_TIC(CasADi::CRSSparsity* obj, std::vector<int > * x0, std::vector<int > * x1);+std::vector<int >* CasADi__CRSSparsity__getNZ_TIC_TIC(CasADi::CRSSparsity* obj, std::vector<int > * x0, std::vector<int > * x1){+ std::vector<int > x0_ = Marshaling<std::vector<int >,std::vector<int > *>::marshal(x0);+ std::vector<int > x1_ = Marshaling<std::vector<int >,std::vector<int > *>::marshal(x1);++ return new std::vector<int >( obj->getNZ(x0_, x1_) );+}+++// ================== Normal method: "hasNZ" ===============+// class: "CasADi::CRSSparsity"+// cppName: "CasADi::CRSSparsity::hasNZ"+// cWrapperName: "CasADi__CRSSparsity__hasNZ"+// protoArgs: "(CasADi::CRSSparsity* obj, int x0, int x1)"+// args: "(x0_, x1_)"+// rettype: Val (NonVec CBool)+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__CRSSparsity__hasNZ(CasADi::CRSSparsity* obj, int x0, int x1)"+// call: "obj->hasNZ(x0_, x1_)"+extern "C"+ bool* CasADi__CRSSparsity__hasNZ(CasADi::CRSSparsity* obj, int x0, int x1);+bool* CasADi__CRSSparsity__hasNZ(CasADi::CRSSparsity* obj, int x0, int x1){+ int x0_ = Marshaling<int,int>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);++ return new bool( obj->hasNZ(x0_, x1_) );+}+++// ================== Normal method: "getNZInplace" ===============+// class: "CasADi::CRSSparsity"+// cppName: "CasADi::CRSSparsity::getNZInplace"+// cWrapperName: "CasADi__CRSSparsity__getNZInplace"+// protoArgs: "(CasADi::CRSSparsity* obj, std::vector<int >* x0)"+// args: "(x0_)"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__CRSSparsity__getNZInplace(CasADi::CRSSparsity* obj, std::vector<int >* x0)"+// call: "obj->getNZInplace(x0_)"+extern "C"+ void CasADi__CRSSparsity__getNZInplace(CasADi::CRSSparsity* obj, std::vector<int >* x0);+void CasADi__CRSSparsity__getNZInplace(CasADi::CRSSparsity* obj, std::vector<int >* x0){+ std::vector<int > x0_ = Marshaling<std::vector<int >,std::vector<int >*>::marshal(x0);++ return obj->getNZInplace(x0_);+}+++// ================== Normal method: "columnsSequential" ===============+// class: "CasADi::CRSSparsity"+// cppName: "CasADi::CRSSparsity::columnsSequential"+// cWrapperName: "CasADi__CRSSparsity__columnsSequential"+// protoArgs: "(CasADi::CRSSparsity* obj, bool* x0)"+// args: "(x0_)"+// rettype: Val (NonVec CBool)+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__CRSSparsity__columnsSequential(CasADi::CRSSparsity* obj, bool* x0)"+// call: "obj->columnsSequential(x0_)"+extern "C"+ bool* CasADi__CRSSparsity__columnsSequential(CasADi::CRSSparsity* obj, bool* x0);+bool* CasADi__CRSSparsity__columnsSequential(CasADi::CRSSparsity* obj, bool* x0){+ bool x0_ = Marshaling<bool,bool*>::marshal(x0);++ return new bool( obj->columnsSequential(x0_) );+}+++// ================== Normal method: "getElements" ===============+// class: "CasADi::CRSSparsity"+// cppName: "CasADi::CRSSparsity::getElements"+// cWrapperName: "CasADi__CRSSparsity__getElements"+// protoArgs: "(CasADi::CRSSparsity* obj, bool* x0)"+// args: "(x0_)"+// rettype: Val (Vec (NonVec CInt))+// cWrapperRetType: "std::vector<int >*"+// proto: "std::vector<int >* CasADi__CRSSparsity__getElements(CasADi::CRSSparsity* obj, bool* x0)"+// call: "obj->getElements(x0_)"+extern "C"+ std::vector<int >* CasADi__CRSSparsity__getElements(CasADi::CRSSparsity* obj, bool* x0);+std::vector<int >* CasADi__CRSSparsity__getElements(CasADi::CRSSparsity* obj, bool* x0){+ bool x0_ = Marshaling<bool,bool*>::marshal(x0);++ return new std::vector<int >( obj->getElements(x0_) );+}+++// ================== Normal method: "unidirectionalColoring" ===============+// class: "CasADi::CRSSparsity"+// cppName: "CasADi::CRSSparsity::unidirectionalColoring"+// cWrapperName: "CasADi__CRSSparsity__unidirectionalColoring"+// protoArgs: "(CasADi::CRSSparsity* obj, CasADi::CRSSparsity* x0, int x1)"+// args: "(x0_, x1_)"+// rettype: Val (NonVec (CasadiClass CRSSparsity))+// cWrapperRetType: "CasADi::CRSSparsity*"+// proto: "CasADi::CRSSparsity* CasADi__CRSSparsity__unidirectionalColoring(CasADi::CRSSparsity* obj, CasADi::CRSSparsity* x0, int x1)"+// call: "obj->unidirectionalColoring(x0_, x1_)"+extern "C"+ CasADi::CRSSparsity* CasADi__CRSSparsity__unidirectionalColoring(CasADi::CRSSparsity* obj, CasADi::CRSSparsity* x0, int x1);+CasADi::CRSSparsity* CasADi__CRSSparsity__unidirectionalColoring(CasADi::CRSSparsity* obj, CasADi::CRSSparsity* x0, int x1){+ CasADi::CRSSparsity x0_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);++ return new CasADi::CRSSparsity( obj->unidirectionalColoring(x0_, x1_) );+}+++// ================== Normal method: "unidirectionalColoring'" ===============+// class: "CasADi::CRSSparsity"+// cppName: "CasADi::CRSSparsity::unidirectionalColoring'"+// cWrapperName: "CasADi__CRSSparsity__unidirectionalColoring_TIC"+// protoArgs: "(CasADi::CRSSparsity* obj, CasADi::CRSSparsity* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass CRSSparsity))+// cWrapperRetType: "CasADi::CRSSparsity*"+// proto: "CasADi::CRSSparsity* CasADi__CRSSparsity__unidirectionalColoring_TIC(CasADi::CRSSparsity* obj, CasADi::CRSSparsity* x0)"+// call: "obj->unidirectionalColoring(x0_)"+extern "C"+ CasADi::CRSSparsity* CasADi__CRSSparsity__unidirectionalColoring_TIC(CasADi::CRSSparsity* obj, CasADi::CRSSparsity* x0);+CasADi::CRSSparsity* CasADi__CRSSparsity__unidirectionalColoring_TIC(CasADi::CRSSparsity* obj, CasADi::CRSSparsity* x0){+ CasADi::CRSSparsity x0_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x0);++ return new CasADi::CRSSparsity( obj->unidirectionalColoring(x0_) );+}+++// ================== Normal method: "unidirectionalColoring''" ===============+// class: "CasADi::CRSSparsity"+// cppName: "CasADi::CRSSparsity::unidirectionalColoring''"+// cWrapperName: "CasADi__CRSSparsity__unidirectionalColoring_TIC_TIC"+// protoArgs: "(CasADi::CRSSparsity* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass CRSSparsity))+// cWrapperRetType: "CasADi::CRSSparsity*"+// proto: "CasADi::CRSSparsity* CasADi__CRSSparsity__unidirectionalColoring_TIC_TIC(CasADi::CRSSparsity* obj)"+// call: "obj->unidirectionalColoring()"+extern "C"+ CasADi::CRSSparsity* CasADi__CRSSparsity__unidirectionalColoring_TIC_TIC(CasADi::CRSSparsity* obj);+CasADi::CRSSparsity* CasADi__CRSSparsity__unidirectionalColoring_TIC_TIC(CasADi::CRSSparsity* obj){++ return new CasADi::CRSSparsity( obj->unidirectionalColoring() );+}+++// ================== Normal method: "starColoring" ===============+// class: "CasADi::CRSSparsity"+// cppName: "CasADi::CRSSparsity::starColoring"+// cWrapperName: "CasADi__CRSSparsity__starColoring"+// protoArgs: "(CasADi::CRSSparsity* obj, int x0, int x1)"+// args: "(x0_, x1_)"+// rettype: Val (NonVec (CasadiClass CRSSparsity))+// cWrapperRetType: "CasADi::CRSSparsity*"+// proto: "CasADi::CRSSparsity* CasADi__CRSSparsity__starColoring(CasADi::CRSSparsity* obj, int x0, int x1)"+// call: "obj->starColoring(x0_, x1_)"+extern "C"+ CasADi::CRSSparsity* CasADi__CRSSparsity__starColoring(CasADi::CRSSparsity* obj, int x0, int x1);+CasADi::CRSSparsity* CasADi__CRSSparsity__starColoring(CasADi::CRSSparsity* obj, int x0, int x1){+ int x0_ = Marshaling<int,int>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);++ return new CasADi::CRSSparsity( obj->starColoring(x0_, x1_) );+}+++// ================== Normal method: "starColoring'" ===============+// class: "CasADi::CRSSparsity"+// cppName: "CasADi::CRSSparsity::starColoring'"+// cWrapperName: "CasADi__CRSSparsity__starColoring_TIC"+// protoArgs: "(CasADi::CRSSparsity* obj, int x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass CRSSparsity))+// cWrapperRetType: "CasADi::CRSSparsity*"+// proto: "CasADi::CRSSparsity* CasADi__CRSSparsity__starColoring_TIC(CasADi::CRSSparsity* obj, int x0)"+// call: "obj->starColoring(x0_)"+extern "C"+ CasADi::CRSSparsity* CasADi__CRSSparsity__starColoring_TIC(CasADi::CRSSparsity* obj, int x0);+CasADi::CRSSparsity* CasADi__CRSSparsity__starColoring_TIC(CasADi::CRSSparsity* obj, int x0){+ int x0_ = Marshaling<int,int>::marshal(x0);++ return new CasADi::CRSSparsity( obj->starColoring(x0_) );+}+++// ================== Normal method: "starColoring''" ===============+// class: "CasADi::CRSSparsity"+// cppName: "CasADi::CRSSparsity::starColoring''"+// cWrapperName: "CasADi__CRSSparsity__starColoring_TIC_TIC"+// protoArgs: "(CasADi::CRSSparsity* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass CRSSparsity))+// cWrapperRetType: "CasADi::CRSSparsity*"+// proto: "CasADi::CRSSparsity* CasADi__CRSSparsity__starColoring_TIC_TIC(CasADi::CRSSparsity* obj)"+// call: "obj->starColoring()"+extern "C"+ CasADi::CRSSparsity* CasADi__CRSSparsity__starColoring_TIC_TIC(CasADi::CRSSparsity* obj);+CasADi::CRSSparsity* CasADi__CRSSparsity__starColoring_TIC_TIC(CasADi::CRSSparsity* obj){++ return new CasADi::CRSSparsity( obj->starColoring() );+}+++// ================== Normal method: "starColoring2" ===============+// class: "CasADi::CRSSparsity"+// cppName: "CasADi::CRSSparsity::starColoring2"+// cWrapperName: "CasADi__CRSSparsity__starColoring2"+// protoArgs: "(CasADi::CRSSparsity* obj, int x0, int x1)"+// args: "(x0_, x1_)"+// rettype: Val (NonVec (CasadiClass CRSSparsity))+// cWrapperRetType: "CasADi::CRSSparsity*"+// proto: "CasADi::CRSSparsity* CasADi__CRSSparsity__starColoring2(CasADi::CRSSparsity* obj, int x0, int x1)"+// call: "obj->starColoring2(x0_, x1_)"+extern "C"+ CasADi::CRSSparsity* CasADi__CRSSparsity__starColoring2(CasADi::CRSSparsity* obj, int x0, int x1);+CasADi::CRSSparsity* CasADi__CRSSparsity__starColoring2(CasADi::CRSSparsity* obj, int x0, int x1){+ int x0_ = Marshaling<int,int>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);++ return new CasADi::CRSSparsity( obj->starColoring2(x0_, x1_) );+}+++// ================== Normal method: "starColoring2'" ===============+// class: "CasADi::CRSSparsity"+// cppName: "CasADi::CRSSparsity::starColoring2'"+// cWrapperName: "CasADi__CRSSparsity__starColoring2_TIC"+// protoArgs: "(CasADi::CRSSparsity* obj, int x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass CRSSparsity))+// cWrapperRetType: "CasADi::CRSSparsity*"+// proto: "CasADi::CRSSparsity* CasADi__CRSSparsity__starColoring2_TIC(CasADi::CRSSparsity* obj, int x0)"+// call: "obj->starColoring2(x0_)"+extern "C"+ CasADi::CRSSparsity* CasADi__CRSSparsity__starColoring2_TIC(CasADi::CRSSparsity* obj, int x0);+CasADi::CRSSparsity* CasADi__CRSSparsity__starColoring2_TIC(CasADi::CRSSparsity* obj, int x0){+ int x0_ = Marshaling<int,int>::marshal(x0);++ return new CasADi::CRSSparsity( obj->starColoring2(x0_) );+}+++// ================== Normal method: "starColoring2''" ===============+// class: "CasADi::CRSSparsity"+// cppName: "CasADi::CRSSparsity::starColoring2''"+// cWrapperName: "CasADi__CRSSparsity__starColoring2_TIC_TIC"+// protoArgs: "(CasADi::CRSSparsity* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass CRSSparsity))+// cWrapperRetType: "CasADi::CRSSparsity*"+// proto: "CasADi::CRSSparsity* CasADi__CRSSparsity__starColoring2_TIC_TIC(CasADi::CRSSparsity* obj)"+// call: "obj->starColoring2()"+extern "C"+ CasADi::CRSSparsity* CasADi__CRSSparsity__starColoring2_TIC_TIC(CasADi::CRSSparsity* obj);+CasADi::CRSSparsity* CasADi__CRSSparsity__starColoring2_TIC_TIC(CasADi::CRSSparsity* obj){++ return new CasADi::CRSSparsity( obj->starColoring2() );+}+++// ================== Normal method: "dimString" ===============+// class: "CasADi::CRSSparsity"+// cppName: "CasADi::CRSSparsity::dimString"+// cWrapperName: "CasADi__CRSSparsity__dimString"+// protoArgs: "(CasADi::CRSSparsity* obj)"+// args: "()"+// rettype: Val (NonVec StdString)+// cWrapperRetType: "std::string*"+// proto: "std::string* CasADi__CRSSparsity__dimString(CasADi::CRSSparsity* obj)"+// call: "obj->dimString()"+extern "C"+ std::string* CasADi__CRSSparsity__dimString(CasADi::CRSSparsity* obj);+std::string* CasADi__CRSSparsity__dimString(CasADi::CRSSparsity* obj){++ return new std::string( obj->dimString() );+}+++// ================== Normal method: "spy'" ===============+// class: "CasADi::CRSSparsity"+// cppName: "CasADi::CRSSparsity::spy'"+// cWrapperName: "CasADi__CRSSparsity__spy_TIC"+// protoArgs: "(CasADi::CRSSparsity* obj)"+// args: "()"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__CRSSparsity__spy_TIC(CasADi::CRSSparsity* obj)"+// call: "obj->spy()"+extern "C"+ void CasADi__CRSSparsity__spy_TIC(CasADi::CRSSparsity* obj);+void CasADi__CRSSparsity__spy_TIC(CasADi::CRSSparsity* obj){++ return obj->spy();+}+++// ================== Normal method: "spyMatlab" ===============+// class: "CasADi::CRSSparsity"+// cppName: "CasADi::CRSSparsity::spyMatlab"+// cWrapperName: "CasADi__CRSSparsity__spyMatlab"+// protoArgs: "(CasADi::CRSSparsity* obj, std::string* x0)"+// args: "(x0_)"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__CRSSparsity__spyMatlab(CasADi::CRSSparsity* obj, std::string* x0)"+// call: "obj->spyMatlab(x0_)"+extern "C"+ void CasADi__CRSSparsity__spyMatlab(CasADi::CRSSparsity* obj, std::string* x0);+void CasADi__CRSSparsity__spyMatlab(CasADi::CRSSparsity* obj, std::string* x0){+ std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);++ return obj->spyMatlab(x0_);+}+++// ================== Normal method: "hash" ===============+// class: "CasADi::CRSSparsity"+// cppName: "CasADi::CRSSparsity::hash"+// cWrapperName: "CasADi__CRSSparsity__hash"+// protoArgs: "(CasADi::CRSSparsity* obj)"+// args: "()"+// rettype: Val (NonVec CSize)+// cWrapperRetType: "size_t"+// proto: "size_t CasADi__CRSSparsity__hash(CasADi::CRSSparsity* obj)"+// call: "obj->hash()"+extern "C"+ size_t CasADi__CRSSparsity__hash(CasADi::CRSSparsity* obj);+size_t CasADi__CRSSparsity__hash(CasADi::CRSSparsity* obj){++ return obj->hash();+}+++// ================== Constructor method: "CRSSparsity" ===============+// class: "CasADi::CRSSparsity"+// cppName: "CasADi::CRSSparsity"+// cWrapperName: "CasADi__CRSSparsity__CRSSparsity"+// protoArgs: "(int x0, int x1, std::vector<int > * x2, std::vector<int > * x3)"+// args: "(x0_, x1_, x2_, x3_)"+// rettype: Val (NonVec (CasadiClass CRSSparsity))+// cWrapperRetType: "CasADi::CRSSparsity*"+// proto: "CasADi::CRSSparsity* CasADi__CRSSparsity__CRSSparsity(int x0, int x1, std::vector<int > * x2, std::vector<int > * x3)"+// call: "CasADi::CRSSparsity(x0_, x1_, x2_, x3_)"+extern "C"+ CasADi::CRSSparsity* CasADi__CRSSparsity__CRSSparsity(int x0, int x1, std::vector<int > * x2, std::vector<int > * x3);+CasADi::CRSSparsity* CasADi__CRSSparsity__CRSSparsity(int x0, int x1, std::vector<int > * x2, std::vector<int > * x3){+ int x0_ = Marshaling<int,int>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);+ std::vector<int > x2_ = Marshaling<std::vector<int >,std::vector<int > *>::marshal(x2);+ std::vector<int > x3_ = Marshaling<std::vector<int >,std::vector<int > *>::marshal(x3);++ return new CasADi::CRSSparsity( CasADi::CRSSparsity(x0_, x1_, x2_, x3_) );+}+++// ================== Constructor method: "CRSSparsity'" ===============+// class: "CasADi::CRSSparsity"+// cppName: "CasADi::CRSSparsity"+// cWrapperName: "CasADi__CRSSparsity__CRSSparsity_TIC"+// protoArgs: "()"+// args: "()"+// rettype: Val (NonVec (CasadiClass CRSSparsity))+// cWrapperRetType: "CasADi::CRSSparsity*"+// proto: "CasADi::CRSSparsity* CasADi__CRSSparsity__CRSSparsity_TIC()"+// call: "CasADi::CRSSparsity()"+extern "C"+ CasADi::CRSSparsity* CasADi__CRSSparsity__CRSSparsity_TIC();+CasADi::CRSSparsity* CasADi__CRSSparsity__CRSSparsity_TIC(){++ return new CasADi::CRSSparsity( CasADi::CRSSparsity() );+}+++// ================== delete CasadiClass GenericType===============+// classType: CasadiClass GenericType+extern "C"+ void delete_CasADi__GenericType(CasADi::GenericType* obj);+void delete_CasADi__GenericType(CasADi::GenericType* obj){+ delete obj;+}+extern "C"+ void delete_std__vector_CasADi__GenericType_(std::vector<CasADi::GenericType* >* obj);+void delete_std__vector_CasADi__GenericType_(std::vector<CasADi::GenericType* >* obj){+ delete obj;+}+extern "C"+ void delete_std__vector_std__vector_CasADi__GenericType__(std::vector<std::vector<CasADi::GenericType* > >* obj);+void delete_std__vector_std__vector_CasADi__GenericType__(std::vector<std::vector<CasADi::GenericType* > >* obj){+ delete obj;+}+extern "C"+ void delete_std__vector_std__vector_std__vector_CasADi__GenericType___(std::vector<std::vector<std::vector<CasADi::GenericType* > > >* obj);+void delete_std__vector_std__vector_std__vector_CasADi__GenericType___(std::vector<std::vector<std::vector<CasADi::GenericType* > > >* obj){+ delete obj;+}++// ================== Static method: "get_type_description" ===============+// class: "CasADi::GenericType"+// cppName: "CasADi::GenericType::get_type_description"+// cWrapperName: "CasADi__GenericType__get_type_description"+// protoArgs: "(CasADi::opt_type* x0)"+// args: "(x0_)"+// rettype: Val (NonVec StdString)+// cWrapperRetType: "std::string*"+// proto: "std::string* CasADi__GenericType__get_type_description(CasADi::opt_type* x0)"+// call: "CasADi::GenericType::get_type_description(x0_)"+extern "C"+ std::string* CasADi__GenericType__get_type_description(CasADi::opt_type* x0);+std::string* CasADi__GenericType__get_type_description(CasADi::opt_type* x0){+ CasADi::opt_type x0_ = Marshaling<CasADi::opt_type,CasADi::opt_type*>::marshal(x0);++ return new std::string( CasADi::GenericType::get_type_description(x0_) );+}+++// ================== Normal method: "get_description" ===============+// class: "CasADi::GenericType"+// cppName: "CasADi::GenericType::get_description"+// cWrapperName: "CasADi__GenericType__get_description"+// protoArgs: "(CasADi::GenericType* obj)"+// args: "()"+// rettype: Val (NonVec StdString)+// cWrapperRetType: "std::string*"+// proto: "std::string* CasADi__GenericType__get_description(CasADi::GenericType* obj)"+// call: "obj->get_description()"+extern "C"+ std::string* CasADi__GenericType__get_description(CasADi::GenericType* obj);+std::string* CasADi__GenericType__get_description(CasADi::GenericType* obj){++ return new std::string( obj->get_description() );+}+++// ================== Static method: "from_type" ===============+// class: "CasADi::GenericType"+// cppName: "CasADi::GenericType::from_type"+// cWrapperName: "CasADi__GenericType__from_type"+// protoArgs: "(CasADi::opt_type x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass GenericType))+// cWrapperRetType: "CasADi::GenericType*"+// proto: "CasADi::GenericType* CasADi__GenericType__from_type(CasADi::opt_type x0)"+// call: "CasADi::GenericType::from_type(x0_)"+extern "C"+ CasADi::GenericType* CasADi__GenericType__from_type(CasADi::opt_type x0);+CasADi::GenericType* CasADi__GenericType__from_type(CasADi::opt_type x0){+ CasADi::opt_type x0_ = Marshaling<CasADi::opt_type,CasADi::opt_type>::marshal(x0);++ return new CasADi::GenericType( CasADi::GenericType::from_type(x0_) );+}+++// ================== Normal method: "getType" ===============+// class: "CasADi::GenericType"+// cppName: "CasADi::GenericType::getType"+// cWrapperName: "CasADi__GenericType__getType"+// protoArgs: "(CasADi::GenericType* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiEnum Opt_type))+// cWrapperRetType: "CasADi::opt_type"+// proto: "CasADi::opt_type CasADi__GenericType__getType(CasADi::GenericType* obj)"+// call: "obj->getType()"+extern "C"+ CasADi::opt_type CasADi__GenericType__getType(CasADi::GenericType* obj);+CasADi::opt_type CasADi__GenericType__getType(CasADi::GenericType* obj){++ return obj->getType();+}+++// ================== Normal method: "can_cast_to" ===============+// class: "CasADi::GenericType"+// cppName: "CasADi::GenericType::can_cast_to"+// cWrapperName: "CasADi__GenericType__can_cast_to"+// protoArgs: "(CasADi::GenericType* obj, CasADi::opt_type x0)"+// args: "(x0_)"+// rettype: Val (NonVec CBool)+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__GenericType__can_cast_to(CasADi::GenericType* obj, CasADi::opt_type x0)"+// call: "obj->can_cast_to(x0_)"+extern "C"+ bool* CasADi__GenericType__can_cast_to(CasADi::GenericType* obj, CasADi::opt_type x0);+bool* CasADi__GenericType__can_cast_to(CasADi::GenericType* obj, CasADi::opt_type x0){+ CasADi::opt_type x0_ = Marshaling<CasADi::opt_type,CasADi::opt_type>::marshal(x0);++ return new bool( obj->can_cast_to(x0_) );+}+++// ================== Normal method: "can_cast_to'" ===============+// class: "CasADi::GenericType"+// cppName: "CasADi::GenericType::can_cast_to'"+// cWrapperName: "CasADi__GenericType__can_cast_to_TIC"+// protoArgs: "(CasADi::GenericType* obj, CasADi::GenericType* x0)"+// args: "(x0_)"+// rettype: Val (NonVec CBool)+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__GenericType__can_cast_to_TIC(CasADi::GenericType* obj, CasADi::GenericType* x0)"+// call: "obj->can_cast_to(x0_)"+extern "C"+ bool* CasADi__GenericType__can_cast_to_TIC(CasADi::GenericType* obj, CasADi::GenericType* x0);+bool* CasADi__GenericType__can_cast_to_TIC(CasADi::GenericType* obj, CasADi::GenericType* x0){+ CasADi::GenericType x0_ = Marshaling<CasADi::GenericType,CasADi::GenericType*>::marshal(x0);++ return new bool( obj->can_cast_to(x0_) );+}+++// ================== Normal method: "isBool" ===============+// class: "CasADi::GenericType"+// cppName: "CasADi::GenericType::isBool"+// cWrapperName: "CasADi__GenericType__isBool"+// protoArgs: "(CasADi::GenericType* obj)"+// args: "()"+// rettype: Val (NonVec CBool)+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__GenericType__isBool(CasADi::GenericType* obj)"+// call: "obj->isBool()"+extern "C"+ bool* CasADi__GenericType__isBool(CasADi::GenericType* obj);+bool* CasADi__GenericType__isBool(CasADi::GenericType* obj){++ return new bool( obj->isBool() );+}+++// ================== Normal method: "isInt" ===============+// class: "CasADi::GenericType"+// cppName: "CasADi::GenericType::isInt"+// cWrapperName: "CasADi__GenericType__isInt"+// protoArgs: "(CasADi::GenericType* obj)"+// args: "()"+// rettype: Val (NonVec CBool)+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__GenericType__isInt(CasADi::GenericType* obj)"+// call: "obj->isInt()"+extern "C"+ bool* CasADi__GenericType__isInt(CasADi::GenericType* obj);+bool* CasADi__GenericType__isInt(CasADi::GenericType* obj){++ return new bool( obj->isInt() );+}+++// ================== Normal method: "isDouble" ===============+// class: "CasADi::GenericType"+// cppName: "CasADi::GenericType::isDouble"+// cWrapperName: "CasADi__GenericType__isDouble"+// protoArgs: "(CasADi::GenericType* obj)"+// args: "()"+// rettype: Val (NonVec CBool)+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__GenericType__isDouble(CasADi::GenericType* obj)"+// call: "obj->isDouble()"+extern "C"+ bool* CasADi__GenericType__isDouble(CasADi::GenericType* obj);+bool* CasADi__GenericType__isDouble(CasADi::GenericType* obj){++ return new bool( obj->isDouble() );+}+++// ================== Normal method: "isString" ===============+// class: "CasADi::GenericType"+// cppName: "CasADi::GenericType::isString"+// cWrapperName: "CasADi__GenericType__isString"+// protoArgs: "(CasADi::GenericType* obj)"+// args: "()"+// rettype: Val (NonVec CBool)+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__GenericType__isString(CasADi::GenericType* obj)"+// call: "obj->isString()"+extern "C"+ bool* CasADi__GenericType__isString(CasADi::GenericType* obj);+bool* CasADi__GenericType__isString(CasADi::GenericType* obj){++ return new bool( obj->isString() );+}+++// ================== Normal method: "isEmptyVector" ===============+// class: "CasADi::GenericType"+// cppName: "CasADi::GenericType::isEmptyVector"+// cWrapperName: "CasADi__GenericType__isEmptyVector"+// protoArgs: "(CasADi::GenericType* obj)"+// args: "()"+// rettype: Val (NonVec CBool)+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__GenericType__isEmptyVector(CasADi::GenericType* obj)"+// call: "obj->isEmptyVector()"+extern "C"+ bool* CasADi__GenericType__isEmptyVector(CasADi::GenericType* obj);+bool* CasADi__GenericType__isEmptyVector(CasADi::GenericType* obj){++ return new bool( obj->isEmptyVector() );+}+++// ================== Normal method: "isIntVector" ===============+// class: "CasADi::GenericType"+// cppName: "CasADi::GenericType::isIntVector"+// cWrapperName: "CasADi__GenericType__isIntVector"+// protoArgs: "(CasADi::GenericType* obj)"+// args: "()"+// rettype: Val (NonVec CBool)+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__GenericType__isIntVector(CasADi::GenericType* obj)"+// call: "obj->isIntVector()"+extern "C"+ bool* CasADi__GenericType__isIntVector(CasADi::GenericType* obj);+bool* CasADi__GenericType__isIntVector(CasADi::GenericType* obj){++ return new bool( obj->isIntVector() );+}+++// ================== Normal method: "isDoubleVector" ===============+// class: "CasADi::GenericType"+// cppName: "CasADi::GenericType::isDoubleVector"+// cWrapperName: "CasADi__GenericType__isDoubleVector"+// protoArgs: "(CasADi::GenericType* obj)"+// args: "()"+// rettype: Val (NonVec CBool)+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__GenericType__isDoubleVector(CasADi::GenericType* obj)"+// call: "obj->isDoubleVector()"+extern "C"+ bool* CasADi__GenericType__isDoubleVector(CasADi::GenericType* obj);+bool* CasADi__GenericType__isDoubleVector(CasADi::GenericType* obj){++ return new bool( obj->isDoubleVector() );+}+++// ================== Normal method: "isStringVector" ===============+// class: "CasADi::GenericType"+// cppName: "CasADi::GenericType::isStringVector"+// cWrapperName: "CasADi__GenericType__isStringVector"+// protoArgs: "(CasADi::GenericType* obj)"+// args: "()"+// rettype: Val (NonVec CBool)+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__GenericType__isStringVector(CasADi::GenericType* obj)"+// call: "obj->isStringVector()"+extern "C"+ bool* CasADi__GenericType__isStringVector(CasADi::GenericType* obj);+bool* CasADi__GenericType__isStringVector(CasADi::GenericType* obj){++ return new bool( obj->isStringVector() );+}+++// ================== Normal method: "isSharedObject" ===============+// class: "CasADi::GenericType"+// cppName: "CasADi::GenericType::isSharedObject"+// cWrapperName: "CasADi__GenericType__isSharedObject"+// protoArgs: "(CasADi::GenericType* obj)"+// args: "()"+// rettype: Val (NonVec CBool)+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__GenericType__isSharedObject(CasADi::GenericType* obj)"+// call: "obj->isSharedObject()"+extern "C"+ bool* CasADi__GenericType__isSharedObject(CasADi::GenericType* obj);+bool* CasADi__GenericType__isSharedObject(CasADi::GenericType* obj){++ return new bool( obj->isSharedObject() );+}+++// ================== Normal method: "isDictionary" ===============+// class: "CasADi::GenericType"+// cppName: "CasADi::GenericType::isDictionary"+// cWrapperName: "CasADi__GenericType__isDictionary"+// protoArgs: "(CasADi::GenericType* obj)"+// args: "()"+// rettype: Val (NonVec CBool)+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__GenericType__isDictionary(CasADi::GenericType* obj)"+// call: "obj->isDictionary()"+extern "C"+ bool* CasADi__GenericType__isDictionary(CasADi::GenericType* obj);+bool* CasADi__GenericType__isDictionary(CasADi::GenericType* obj){++ return new bool( obj->isDictionary() );+}+++// ================== Normal method: "isFX" ===============+// class: "CasADi::GenericType"+// cppName: "CasADi::GenericType::isFX"+// cWrapperName: "CasADi__GenericType__isFX"+// protoArgs: "(CasADi::GenericType* obj)"+// args: "()"+// rettype: Val (NonVec CBool)+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__GenericType__isFX(CasADi::GenericType* obj)"+// call: "obj->isFX()"+extern "C"+ bool* CasADi__GenericType__isFX(CasADi::GenericType* obj);+bool* CasADi__GenericType__isFX(CasADi::GenericType* obj){++ return new bool( obj->isFX() );+}+++// ================== Normal method: "toBool" ===============+// class: "CasADi::GenericType"+// cppName: "CasADi::GenericType::toBool"+// cWrapperName: "CasADi__GenericType__toBool"+// protoArgs: "(CasADi::GenericType* obj)"+// args: "()"+// rettype: Val (NonVec CBool)+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__GenericType__toBool(CasADi::GenericType* obj)"+// call: "obj->toBool()"+extern "C"+ bool* CasADi__GenericType__toBool(CasADi::GenericType* obj);+bool* CasADi__GenericType__toBool(CasADi::GenericType* obj){++ return new bool( obj->toBool() );+}+++// ================== Normal method: "toInt" ===============+// class: "CasADi::GenericType"+// cppName: "CasADi::GenericType::toInt"+// cWrapperName: "CasADi__GenericType__toInt"+// protoArgs: "(CasADi::GenericType* obj)"+// args: "()"+// rettype: Val (NonVec CInt)+// cWrapperRetType: "int"+// proto: "int CasADi__GenericType__toInt(CasADi::GenericType* obj)"+// call: "obj->toInt()"+extern "C"+ int CasADi__GenericType__toInt(CasADi::GenericType* obj);+int CasADi__GenericType__toInt(CasADi::GenericType* obj){++ return obj->toInt();+}+++// ================== Normal method: "toDouble" ===============+// class: "CasADi::GenericType"+// cppName: "CasADi::GenericType::toDouble"+// cWrapperName: "CasADi__GenericType__toDouble"+// protoArgs: "(CasADi::GenericType* obj)"+// args: "()"+// rettype: Val (NonVec CDouble)+// cWrapperRetType: "double"+// proto: "double CasADi__GenericType__toDouble(CasADi::GenericType* obj)"+// call: "obj->toDouble()"+extern "C"+ double CasADi__GenericType__toDouble(CasADi::GenericType* obj);+double CasADi__GenericType__toDouble(CasADi::GenericType* obj){++ return obj->toDouble();+}+++// ================== Normal method: "operator ==" ===============+// class: "CasADi::GenericType"+// cppName: "CasADi::GenericType::operator =="+// cWrapperName: "CasADi__GenericType__operator_equals"+// protoArgs: "(CasADi::GenericType* obj, CasADi::GenericType* x0)"+// args: "(x0_)"+// rettype: Val (NonVec CBool)+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__GenericType__operator_equals(CasADi::GenericType* obj, CasADi::GenericType* x0)"+// call: "obj->operator ==(x0_)"+extern "C"+ bool* CasADi__GenericType__operator_equals(CasADi::GenericType* obj, CasADi::GenericType* x0);+bool* CasADi__GenericType__operator_equals(CasADi::GenericType* obj, CasADi::GenericType* x0){+ CasADi::GenericType x0_ = Marshaling<CasADi::GenericType,CasADi::GenericType*>::marshal(x0);++ return new bool( obj->operator ==(x0_) );+}+++// ================== Normal method: "operator !=" ===============+// class: "CasADi::GenericType"+// cppName: "CasADi::GenericType::operator !="+// cWrapperName: "CasADi__GenericType__operator_nequals"+// protoArgs: "(CasADi::GenericType* obj, CasADi::GenericType* x0)"+// args: "(x0_)"+// rettype: Val (NonVec CBool)+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__GenericType__operator_nequals(CasADi::GenericType* obj, CasADi::GenericType* x0)"+// call: "obj->operator !=(x0_)"+extern "C"+ bool* CasADi__GenericType__operator_nequals(CasADi::GenericType* obj, CasADi::GenericType* x0);+bool* CasADi__GenericType__operator_nequals(CasADi::GenericType* obj, CasADi::GenericType* x0){+ CasADi::GenericType x0_ = Marshaling<CasADi::GenericType,CasADi::GenericType*>::marshal(x0);++ return new bool( obj->operator !=(x0_) );+}+++// ================== Constructor method: "GenericTypeBool" ===============+// class: "CasADi::GenericType"+// cppName: "CasADi::GenericType"+// cWrapperName: "CasADi__GenericType__GenericTypeBool"+// protoArgs: "(bool* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass GenericType))+// cWrapperRetType: "CasADi::GenericType*"+// proto: "CasADi::GenericType* CasADi__GenericType__GenericTypeBool(bool* x0)"+// call: "CasADi::GenericType(x0_)"+extern "C"+ CasADi::GenericType* CasADi__GenericType__GenericTypeBool(bool* x0);+CasADi::GenericType* CasADi__GenericType__GenericTypeBool(bool* x0){+ bool x0_ = Marshaling<bool,bool*>::marshal(x0);++ return new CasADi::GenericType( CasADi::GenericType(x0_) );+}+++// ================== Constructor method: "GenericTypeInt" ===============+// class: "CasADi::GenericType"+// cppName: "CasADi::GenericType"+// cWrapperName: "CasADi__GenericType__GenericTypeInt"+// protoArgs: "(int x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass GenericType))+// cWrapperRetType: "CasADi::GenericType*"+// proto: "CasADi::GenericType* CasADi__GenericType__GenericTypeInt(int x0)"+// call: "CasADi::GenericType(x0_)"+extern "C"+ CasADi::GenericType* CasADi__GenericType__GenericTypeInt(int x0);+CasADi::GenericType* CasADi__GenericType__GenericTypeInt(int x0){+ int x0_ = Marshaling<int,int>::marshal(x0);++ return new CasADi::GenericType( CasADi::GenericType(x0_) );+}+++// ================== Constructor method: "GenericTypeDouble" ===============+// class: "CasADi::GenericType"+// cppName: "CasADi::GenericType"+// cWrapperName: "CasADi__GenericType__GenericTypeDouble"+// protoArgs: "(double x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass GenericType))+// cWrapperRetType: "CasADi::GenericType*"+// proto: "CasADi::GenericType* CasADi__GenericType__GenericTypeDouble(double x0)"+// call: "CasADi::GenericType(x0_)"+extern "C"+ CasADi::GenericType* CasADi__GenericType__GenericTypeDouble(double x0);+CasADi::GenericType* CasADi__GenericType__GenericTypeDouble(double x0){+ double x0_ = Marshaling<double,double>::marshal(x0);++ return new CasADi::GenericType( CasADi::GenericType(x0_) );+}+++// ================== Constructor method: "GenericTypeString" ===============+// class: "CasADi::GenericType"+// cppName: "CasADi::GenericType"+// cWrapperName: "CasADi__GenericType__GenericTypeString"+// protoArgs: "(std::string* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass GenericType))+// cWrapperRetType: "CasADi::GenericType*"+// proto: "CasADi::GenericType* CasADi__GenericType__GenericTypeString(std::string* x0)"+// call: "CasADi::GenericType(x0_)"+extern "C"+ CasADi::GenericType* CasADi__GenericType__GenericTypeString(std::string* x0);+CasADi::GenericType* CasADi__GenericType__GenericTypeString(std::string* x0){+ std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);++ return new CasADi::GenericType( CasADi::GenericType(x0_) );+}+++// ================== Constructor method: "GenericTypeBoolVec" ===============+// class: "CasADi::GenericType"+// cppName: "CasADi::GenericType"+// cWrapperName: "CasADi__GenericType__GenericTypeBoolVec"+// protoArgs: "(std::vector<bool* > * x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass GenericType))+// cWrapperRetType: "CasADi::GenericType*"+// proto: "CasADi::GenericType* CasADi__GenericType__GenericTypeBoolVec(std::vector<bool* > * x0)"+// call: "CasADi::GenericType(x0_)"+extern "C"+ CasADi::GenericType* CasADi__GenericType__GenericTypeBoolVec(std::vector<bool* > * x0);+CasADi::GenericType* CasADi__GenericType__GenericTypeBoolVec(std::vector<bool* > * x0){+ std::vector<bool > x0_ = Marshaling<std::vector<bool >,std::vector<bool* > *>::marshal(x0);++ return new CasADi::GenericType( CasADi::GenericType(x0_) );+}+++// ================== Constructor method: "GenericTypeIntVec" ===============+// class: "CasADi::GenericType"+// cppName: "CasADi::GenericType"+// cWrapperName: "CasADi__GenericType__GenericTypeIntVec"+// protoArgs: "(std::vector<int > * x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass GenericType))+// cWrapperRetType: "CasADi::GenericType*"+// proto: "CasADi::GenericType* CasADi__GenericType__GenericTypeIntVec(std::vector<int > * x0)"+// call: "CasADi::GenericType(x0_)"+extern "C"+ CasADi::GenericType* CasADi__GenericType__GenericTypeIntVec(std::vector<int > * x0);+CasADi::GenericType* CasADi__GenericType__GenericTypeIntVec(std::vector<int > * x0){+ std::vector<int > x0_ = Marshaling<std::vector<int >,std::vector<int > *>::marshal(x0);++ return new CasADi::GenericType( CasADi::GenericType(x0_) );+}+++// ================== Constructor method: "GenericTypeDoubleVec" ===============+// class: "CasADi::GenericType"+// cppName: "CasADi::GenericType"+// cWrapperName: "CasADi__GenericType__GenericTypeDoubleVec"+// protoArgs: "(std::vector<double > * x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass GenericType))+// cWrapperRetType: "CasADi::GenericType*"+// proto: "CasADi::GenericType* CasADi__GenericType__GenericTypeDoubleVec(std::vector<double > * x0)"+// call: "CasADi::GenericType(x0_)"+extern "C"+ CasADi::GenericType* CasADi__GenericType__GenericTypeDoubleVec(std::vector<double > * x0);+CasADi::GenericType* CasADi__GenericType__GenericTypeDoubleVec(std::vector<double > * x0){+ std::vector<double > x0_ = Marshaling<std::vector<double >,std::vector<double > *>::marshal(x0);++ return new CasADi::GenericType( CasADi::GenericType(x0_) );+}+++// ================== Constructor method: "GenericTypeStringVec" ===============+// class: "CasADi::GenericType"+// cppName: "CasADi::GenericType"+// cWrapperName: "CasADi__GenericType__GenericTypeStringVec"+// protoArgs: "(std::vector<std::string* > * x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass GenericType))+// cWrapperRetType: "CasADi::GenericType*"+// proto: "CasADi::GenericType* CasADi__GenericType__GenericTypeStringVec(std::vector<std::string* > * x0)"+// call: "CasADi::GenericType(x0_)"+extern "C"+ CasADi::GenericType* CasADi__GenericType__GenericTypeStringVec(std::vector<std::string* > * x0);+CasADi::GenericType* CasADi__GenericType__GenericTypeStringVec(std::vector<std::string* > * x0){+ std::vector<std::string > x0_ = Marshaling<std::vector<std::string >,std::vector<std::string* > *>::marshal(x0);++ return new CasADi::GenericType( CasADi::GenericType(x0_) );+}+++// ================== Constructor method: "GenericTypeFX" ===============+// class: "CasADi::GenericType"+// cppName: "CasADi::GenericType"+// cWrapperName: "CasADi__GenericType__GenericTypeFX"+// protoArgs: "(CasADi::FX* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass GenericType))+// cWrapperRetType: "CasADi::GenericType*"+// proto: "CasADi::GenericType* CasADi__GenericType__GenericTypeFX(CasADi::FX* x0)"+// call: "CasADi::GenericType(x0_)"+extern "C"+ CasADi::GenericType* CasADi__GenericType__GenericTypeFX(CasADi::FX* x0);+CasADi::GenericType* CasADi__GenericType__GenericTypeFX(CasADi::FX* x0){+ CasADi::FX x0_ = Marshaling<CasADi::FX,CasADi::FX*>::marshal(x0);++ return new CasADi::GenericType( CasADi::GenericType(x0_) );+}+++// ================== Constructor method: "GenericTypeCallback" ===============+// class: "CasADi::GenericType"+// cppName: "CasADi::GenericType"+// cWrapperName: "CasADi__GenericType__GenericTypeCallback"+// protoArgs: "(CasADi::Callback* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass GenericType))+// cWrapperRetType: "CasADi::GenericType*"+// proto: "CasADi::GenericType* CasADi__GenericType__GenericTypeCallback(CasADi::Callback* x0)"+// call: "CasADi::GenericType(x0_)"+extern "C"+ CasADi::GenericType* CasADi__GenericType__GenericTypeCallback(CasADi::Callback* x0);+CasADi::GenericType* CasADi__GenericType__GenericTypeCallback(CasADi::Callback* x0){+ CasADi::Callback x0_ = Marshaling<CasADi::Callback,CasADi::Callback*>::marshal(x0);++ return new CasADi::GenericType( CasADi::GenericType(x0_) );+}+++// ================== Constructor method: "GenericType" ===============+// class: "CasADi::GenericType"+// cppName: "CasADi::GenericType"+// cWrapperName: "CasADi__GenericType__GenericType"+// protoArgs: "()"+// args: "()"+// rettype: Val (NonVec (CasadiClass GenericType))+// cWrapperRetType: "CasADi::GenericType*"+// proto: "CasADi::GenericType* CasADi__GenericType__GenericType()"+// call: "CasADi::GenericType()"+extern "C"+ CasADi::GenericType* CasADi__GenericType__GenericType();+CasADi::GenericType* CasADi__GenericType__GenericType(){++ return new CasADi::GenericType( CasADi::GenericType() );+}+++// ================== delete CasadiClass IOInterfaceFX===============+// classType: CasadiClass IOInterfaceFX+extern "C"+ void delete_CasADi__IOInterface_CasADi__FX_(CasADi::IOInterface< CasADi::FX >* obj);+void delete_CasADi__IOInterface_CasADi__FX_(CasADi::IOInterface< CasADi::FX >* obj){+ delete obj;+}+extern "C"+ void delete_std__vector_CasADi__IOInterface_CasADi__FX__(std::vector<CasADi::IOInterface< CasADi::FX >* >* obj);+void delete_std__vector_CasADi__IOInterface_CasADi__FX__(std::vector<CasADi::IOInterface< CasADi::FX >* >* obj){+ delete obj;+}+extern "C"+ void delete_std__vector_std__vector_CasADi__IOInterface_CasADi__FX___(std::vector<std::vector<CasADi::IOInterface< CasADi::FX >* > >* obj);+void delete_std__vector_std__vector_CasADi__IOInterface_CasADi__FX___(std::vector<std::vector<CasADi::IOInterface< CasADi::FX >* > >* obj){+ delete obj;+}+extern "C"+ void delete_std__vector_std__vector_std__vector_CasADi__IOInterface_CasADi__FX____(std::vector<std::vector<std::vector<CasADi::IOInterface< CasADi::FX >* > > >* obj);+void delete_std__vector_std__vector_std__vector_CasADi__IOInterface_CasADi__FX____(std::vector<std::vector<std::vector<CasADi::IOInterface< CasADi::FX >* > > >* obj){+ delete obj;+}++// ================== Normal method: "input" ===============+// class: "CasADi::IOInterface< CasADi::FX >"+// cppName: "CasADi::IOInterface< CasADi::FX >::input"+// cWrapperName: "CasADi__IOInterface_CasADi__FX___input"+// protoArgs: "(CasADi::IOInterface< CasADi::FX >* obj, int x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass DMatrix))+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__IOInterface_CasADi__FX___input(CasADi::IOInterface< CasADi::FX >* obj, int x0)"+// call: "obj->input(x0_)"+extern "C"+ CasADi::Matrix< double >* CasADi__IOInterface_CasADi__FX___input(CasADi::IOInterface< CasADi::FX >* obj, int x0);+CasADi::Matrix< double >* CasADi__IOInterface_CasADi__FX___input(CasADi::IOInterface< CasADi::FX >* obj, int x0){+ int x0_ = Marshaling<int,int>::marshal(x0);++ return new CasADi::Matrix< double >( obj->input(x0_) );+}+++// ================== Normal method: "input'" ===============+// class: "CasADi::IOInterface< CasADi::FX >"+// cppName: "CasADi::IOInterface< CasADi::FX >::input'"+// cWrapperName: "CasADi__IOInterface_CasADi__FX___input_TIC"+// protoArgs: "(CasADi::IOInterface< CasADi::FX >* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass DMatrix))+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__IOInterface_CasADi__FX___input_TIC(CasADi::IOInterface< CasADi::FX >* obj)"+// call: "obj->input()"+extern "C"+ CasADi::Matrix< double >* CasADi__IOInterface_CasADi__FX___input_TIC(CasADi::IOInterface< CasADi::FX >* obj);+CasADi::Matrix< double >* CasADi__IOInterface_CasADi__FX___input_TIC(CasADi::IOInterface< CasADi::FX >* obj){++ return new CasADi::Matrix< double >( obj->input() );+}+++// ================== Normal method: "input''" ===============+// class: "CasADi::IOInterface< CasADi::FX >"+// cppName: "CasADi::IOInterface< CasADi::FX >::input''"+// cWrapperName: "CasADi__IOInterface_CasADi__FX___input_TIC_TIC"+// protoArgs: "(CasADi::IOInterface< CasADi::FX >* obj, std::string* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass DMatrix))+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__IOInterface_CasADi__FX___input_TIC_TIC(CasADi::IOInterface< CasADi::FX >* obj, std::string* x0)"+// call: "obj->input(x0_)"+extern "C"+ CasADi::Matrix< double >* CasADi__IOInterface_CasADi__FX___input_TIC_TIC(CasADi::IOInterface< CasADi::FX >* obj, std::string* x0);+CasADi::Matrix< double >* CasADi__IOInterface_CasADi__FX___input_TIC_TIC(CasADi::IOInterface< CasADi::FX >* obj, std::string* x0){+ std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);++ return new CasADi::Matrix< double >( obj->input(x0_) );+}+++// ================== Normal method: "output" ===============+// class: "CasADi::IOInterface< CasADi::FX >"+// cppName: "CasADi::IOInterface< CasADi::FX >::output"+// cWrapperName: "CasADi__IOInterface_CasADi__FX___output"+// protoArgs: "(CasADi::IOInterface< CasADi::FX >* obj, int x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass DMatrix))+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__IOInterface_CasADi__FX___output(CasADi::IOInterface< CasADi::FX >* obj, int x0)"+// call: "obj->output(x0_)"+extern "C"+ CasADi::Matrix< double >* CasADi__IOInterface_CasADi__FX___output(CasADi::IOInterface< CasADi::FX >* obj, int x0);+CasADi::Matrix< double >* CasADi__IOInterface_CasADi__FX___output(CasADi::IOInterface< CasADi::FX >* obj, int x0){+ int x0_ = Marshaling<int,int>::marshal(x0);++ return new CasADi::Matrix< double >( obj->output(x0_) );+}+++// ================== Normal method: "output'" ===============+// class: "CasADi::IOInterface< CasADi::FX >"+// cppName: "CasADi::IOInterface< CasADi::FX >::output'"+// cWrapperName: "CasADi__IOInterface_CasADi__FX___output_TIC"+// protoArgs: "(CasADi::IOInterface< CasADi::FX >* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass DMatrix))+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__IOInterface_CasADi__FX___output_TIC(CasADi::IOInterface< CasADi::FX >* obj)"+// call: "obj->output()"+extern "C"+ CasADi::Matrix< double >* CasADi__IOInterface_CasADi__FX___output_TIC(CasADi::IOInterface< CasADi::FX >* obj);+CasADi::Matrix< double >* CasADi__IOInterface_CasADi__FX___output_TIC(CasADi::IOInterface< CasADi::FX >* obj){++ return new CasADi::Matrix< double >( obj->output() );+}+++// ================== Normal method: "output''" ===============+// class: "CasADi::IOInterface< CasADi::FX >"+// cppName: "CasADi::IOInterface< CasADi::FX >::output''"+// cWrapperName: "CasADi__IOInterface_CasADi__FX___output_TIC_TIC"+// protoArgs: "(CasADi::IOInterface< CasADi::FX >* obj, std::string* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass DMatrix))+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__IOInterface_CasADi__FX___output_TIC_TIC(CasADi::IOInterface< CasADi::FX >* obj, std::string* x0)"+// call: "obj->output(x0_)"+extern "C"+ CasADi::Matrix< double >* CasADi__IOInterface_CasADi__FX___output_TIC_TIC(CasADi::IOInterface< CasADi::FX >* obj, std::string* x0);+CasADi::Matrix< double >* CasADi__IOInterface_CasADi__FX___output_TIC_TIC(CasADi::IOInterface< CasADi::FX >* obj, std::string* x0){+ std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);++ return new CasADi::Matrix< double >( obj->output(x0_) );+}+++// ================== Normal method: "getNumInputs" ===============+// class: "CasADi::IOInterface< CasADi::FX >"+// cppName: "CasADi::IOInterface< CasADi::FX >::getNumInputs"+// cWrapperName: "CasADi__IOInterface_CasADi__FX___getNumInputs"+// protoArgs: "(CasADi::IOInterface< CasADi::FX >* obj)"+// args: "()"+// rettype: Val (NonVec CInt)+// cWrapperRetType: "int"+// proto: "int CasADi__IOInterface_CasADi__FX___getNumInputs(CasADi::IOInterface< CasADi::FX >* obj)"+// call: "obj->getNumInputs()"+extern "C"+ int CasADi__IOInterface_CasADi__FX___getNumInputs(CasADi::IOInterface< CasADi::FX >* obj);+int CasADi__IOInterface_CasADi__FX___getNumInputs(CasADi::IOInterface< CasADi::FX >* obj){++ return obj->getNumInputs();+}+++// ================== Normal method: "getNumOutputs" ===============+// class: "CasADi::IOInterface< CasADi::FX >"+// cppName: "CasADi::IOInterface< CasADi::FX >::getNumOutputs"+// cWrapperName: "CasADi__IOInterface_CasADi__FX___getNumOutputs"+// protoArgs: "(CasADi::IOInterface< CasADi::FX >* obj)"+// args: "()"+// rettype: Val (NonVec CInt)+// cWrapperRetType: "int"+// proto: "int CasADi__IOInterface_CasADi__FX___getNumOutputs(CasADi::IOInterface< CasADi::FX >* obj)"+// call: "obj->getNumOutputs()"+extern "C"+ int CasADi__IOInterface_CasADi__FX___getNumOutputs(CasADi::IOInterface< CasADi::FX >* obj);+int CasADi__IOInterface_CasADi__FX___getNumOutputs(CasADi::IOInterface< CasADi::FX >* obj){++ return obj->getNumOutputs();+}+++// ================== Normal method: "getInputScheme" ===============+// class: "CasADi::IOInterface< CasADi::FX >"+// cppName: "CasADi::IOInterface< CasADi::FX >::getInputScheme"+// cWrapperName: "CasADi__IOInterface_CasADi__FX___getInputScheme"+// protoArgs: "(CasADi::IOInterface< CasADi::FX >* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass IOScheme))+// cWrapperRetType: "CasADi::IOScheme*"+// proto: "CasADi::IOScheme* CasADi__IOInterface_CasADi__FX___getInputScheme(CasADi::IOInterface< CasADi::FX >* obj)"+// call: "obj->getInputScheme()"+extern "C"+ CasADi::IOScheme* CasADi__IOInterface_CasADi__FX___getInputScheme(CasADi::IOInterface< CasADi::FX >* obj);+CasADi::IOScheme* CasADi__IOInterface_CasADi__FX___getInputScheme(CasADi::IOInterface< CasADi::FX >* obj){++ return new CasADi::IOScheme( obj->getInputScheme() );+}+++// ================== Normal method: "getOutputScheme" ===============+// class: "CasADi::IOInterface< CasADi::FX >"+// cppName: "CasADi::IOInterface< CasADi::FX >::getOutputScheme"+// cWrapperName: "CasADi__IOInterface_CasADi__FX___getOutputScheme"+// protoArgs: "(CasADi::IOInterface< CasADi::FX >* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass IOScheme))+// cWrapperRetType: "CasADi::IOScheme*"+// proto: "CasADi::IOScheme* CasADi__IOInterface_CasADi__FX___getOutputScheme(CasADi::IOInterface< CasADi::FX >* obj)"+// call: "obj->getOutputScheme()"+extern "C"+ CasADi::IOScheme* CasADi__IOInterface_CasADi__FX___getOutputScheme(CasADi::IOInterface< CasADi::FX >* obj);+CasADi::IOScheme* CasADi__IOInterface_CasADi__FX___getOutputScheme(CasADi::IOInterface< CasADi::FX >* obj){++ return new CasADi::IOScheme( obj->getOutputScheme() );+}+++// ================== Normal method: "inputSchemeEntry" ===============+// class: "CasADi::IOInterface< CasADi::FX >"+// cppName: "CasADi::IOInterface< CasADi::FX >::inputSchemeEntry"+// cWrapperName: "CasADi__IOInterface_CasADi__FX___inputSchemeEntry"+// protoArgs: "(CasADi::IOInterface< CasADi::FX >* obj, std::string* x0)"+// args: "(x0_)"+// rettype: Val (NonVec CInt)+// cWrapperRetType: "int"+// proto: "int CasADi__IOInterface_CasADi__FX___inputSchemeEntry(CasADi::IOInterface< CasADi::FX >* obj, std::string* x0)"+// call: "obj->inputSchemeEntry(x0_)"+extern "C"+ int CasADi__IOInterface_CasADi__FX___inputSchemeEntry(CasADi::IOInterface< CasADi::FX >* obj, std::string* x0);+int CasADi__IOInterface_CasADi__FX___inputSchemeEntry(CasADi::IOInterface< CasADi::FX >* obj, std::string* x0){+ std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);++ return obj->inputSchemeEntry(x0_);+}+++// ================== Normal method: "outputSchemeEntry" ===============+// class: "CasADi::IOInterface< CasADi::FX >"+// cppName: "CasADi::IOInterface< CasADi::FX >::outputSchemeEntry"+// cWrapperName: "CasADi__IOInterface_CasADi__FX___outputSchemeEntry"+// protoArgs: "(CasADi::IOInterface< CasADi::FX >* obj, std::string* x0)"+// args: "(x0_)"+// rettype: Val (NonVec CInt)+// cWrapperRetType: "int"+// proto: "int CasADi__IOInterface_CasADi__FX___outputSchemeEntry(CasADi::IOInterface< CasADi::FX >* obj, std::string* x0)"+// call: "obj->outputSchemeEntry(x0_)"+extern "C"+ int CasADi__IOInterface_CasADi__FX___outputSchemeEntry(CasADi::IOInterface< CasADi::FX >* obj, std::string* x0);+int CasADi__IOInterface_CasADi__FX___outputSchemeEntry(CasADi::IOInterface< CasADi::FX >* obj, std::string* x0){+ std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);++ return obj->outputSchemeEntry(x0_);+}+++// ================== Normal method: "schemeEntry" ===============+// class: "CasADi::IOInterface< CasADi::FX >"+// cppName: "CasADi::IOInterface< CasADi::FX >::schemeEntry"+// cWrapperName: "CasADi__IOInterface_CasADi__FX___schemeEntry"+// protoArgs: "(CasADi::IOInterface< CasADi::FX >* obj, CasADi::IOScheme* x0, std::string* x1, bool* x2)"+// args: "(x0_, x1_, x2_)"+// rettype: Val (NonVec CInt)+// cWrapperRetType: "int"+// proto: "int CasADi__IOInterface_CasADi__FX___schemeEntry(CasADi::IOInterface< CasADi::FX >* obj, CasADi::IOScheme* x0, std::string* x1, bool* x2)"+// call: "obj->schemeEntry(x0_, x1_, x2_)"+extern "C"+ int CasADi__IOInterface_CasADi__FX___schemeEntry(CasADi::IOInterface< CasADi::FX >* obj, CasADi::IOScheme* x0, std::string* x1, bool* x2);+int CasADi__IOInterface_CasADi__FX___schemeEntry(CasADi::IOInterface< CasADi::FX >* obj, CasADi::IOScheme* x0, std::string* x1, bool* x2){+ CasADi::IOScheme x0_ = Marshaling<CasADi::IOScheme,CasADi::IOScheme*>::marshal(x0);+ std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);+ bool x2_ = Marshaling<bool,bool*>::marshal(x2);++ return obj->schemeEntry(x0_, x1_, x2_);+}+++// ================== Normal method: "setInput" ===============+// class: "CasADi::IOInterface< CasADi::FX >"+// cppName: "CasADi::IOInterface< CasADi::FX >::setInput"+// cWrapperName: "CasADi__IOInterface_CasADi__FX___setInput"+// protoArgs: "(CasADi::IOInterface< CasADi::FX >* obj, double x0, int x1)"+// args: "(x0_, x1_)"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__IOInterface_CasADi__FX___setInput(CasADi::IOInterface< CasADi::FX >* obj, double x0, int x1)"+// call: "obj->setInput(x0_, x1_)"+extern "C"+ void CasADi__IOInterface_CasADi__FX___setInput(CasADi::IOInterface< CasADi::FX >* obj, double x0, int x1);+void CasADi__IOInterface_CasADi__FX___setInput(CasADi::IOInterface< CasADi::FX >* obj, double x0, int x1){+ double x0_ = Marshaling<double,double>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);++ return obj->setInput(x0_, x1_);+}+++// ================== Normal method: "setInput'" ===============+// class: "CasADi::IOInterface< CasADi::FX >"+// cppName: "CasADi::IOInterface< CasADi::FX >::setInput'"+// cWrapperName: "CasADi__IOInterface_CasADi__FX___setInput_TIC"+// protoArgs: "(CasADi::IOInterface< CasADi::FX >* obj, double x0)"+// args: "(x0_)"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__IOInterface_CasADi__FX___setInput_TIC(CasADi::IOInterface< CasADi::FX >* obj, double x0)"+// call: "obj->setInput(x0_)"+extern "C"+ void CasADi__IOInterface_CasADi__FX___setInput_TIC(CasADi::IOInterface< CasADi::FX >* obj, double x0);+void CasADi__IOInterface_CasADi__FX___setInput_TIC(CasADi::IOInterface< CasADi::FX >* obj, double x0){+ double x0_ = Marshaling<double,double>::marshal(x0);++ return obj->setInput(x0_);+}+++// ================== Normal method: "setOutput" ===============+// class: "CasADi::IOInterface< CasADi::FX >"+// cppName: "CasADi::IOInterface< CasADi::FX >::setOutput"+// cWrapperName: "CasADi__IOInterface_CasADi__FX___setOutput"+// protoArgs: "(CasADi::IOInterface< CasADi::FX >* obj, double x0, int x1)"+// args: "(x0_, x1_)"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__IOInterface_CasADi__FX___setOutput(CasADi::IOInterface< CasADi::FX >* obj, double x0, int x1)"+// call: "obj->setOutput(x0_, x1_)"+extern "C"+ void CasADi__IOInterface_CasADi__FX___setOutput(CasADi::IOInterface< CasADi::FX >* obj, double x0, int x1);+void CasADi__IOInterface_CasADi__FX___setOutput(CasADi::IOInterface< CasADi::FX >* obj, double x0, int x1){+ double x0_ = Marshaling<double,double>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);++ return obj->setOutput(x0_, x1_);+}+++// ================== Normal method: "setOutput'" ===============+// class: "CasADi::IOInterface< CasADi::FX >"+// cppName: "CasADi::IOInterface< CasADi::FX >::setOutput'"+// cWrapperName: "CasADi__IOInterface_CasADi__FX___setOutput_TIC"+// protoArgs: "(CasADi::IOInterface< CasADi::FX >* obj, double x0)"+// args: "(x0_)"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__IOInterface_CasADi__FX___setOutput_TIC(CasADi::IOInterface< CasADi::FX >* obj, double x0)"+// call: "obj->setOutput(x0_)"+extern "C"+ void CasADi__IOInterface_CasADi__FX___setOutput_TIC(CasADi::IOInterface< CasADi::FX >* obj, double x0);+void CasADi__IOInterface_CasADi__FX___setOutput_TIC(CasADi::IOInterface< CasADi::FX >* obj, double x0){+ double x0_ = Marshaling<double,double>::marshal(x0);++ return obj->setOutput(x0_);+}+++// ================== Normal method: "setOutput''" ===============+// class: "CasADi::IOInterface< CasADi::FX >"+// cppName: "CasADi::IOInterface< CasADi::FX >::setOutput''"+// cWrapperName: "CasADi__IOInterface_CasADi__FX___setOutput_TIC_TIC"+// protoArgs: "(CasADi::IOInterface< CasADi::FX >* obj, double x0, std::string* x1)"+// args: "(x0_, x1_)"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__IOInterface_CasADi__FX___setOutput_TIC_TIC(CasADi::IOInterface< CasADi::FX >* obj, double x0, std::string* x1)"+// call: "obj->setOutput(x0_, x1_)"+extern "C"+ void CasADi__IOInterface_CasADi__FX___setOutput_TIC_TIC(CasADi::IOInterface< CasADi::FX >* obj, double x0, std::string* x1);+void CasADi__IOInterface_CasADi__FX___setOutput_TIC_TIC(CasADi::IOInterface< CasADi::FX >* obj, double x0, std::string* x1){+ double x0_ = Marshaling<double,double>::marshal(x0);+ std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);++ return obj->setOutput(x0_, x1_);+}+++// ================== Normal method: "setInput'''" ===============+// class: "CasADi::IOInterface< CasADi::FX >"+// cppName: "CasADi::IOInterface< CasADi::FX >::setInput'''"+// cWrapperName: "CasADi__IOInterface_CasADi__FX___setInput_TIC_TIC_TIC"+// protoArgs: "(CasADi::IOInterface< CasADi::FX >* obj, std::vector<double > * x0, int x1)"+// args: "(x0_, x1_)"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__IOInterface_CasADi__FX___setInput_TIC_TIC_TIC(CasADi::IOInterface< CasADi::FX >* obj, std::vector<double > * x0, int x1)"+// call: "obj->setInput(x0_, x1_)"+extern "C"+ void CasADi__IOInterface_CasADi__FX___setInput_TIC_TIC_TIC(CasADi::IOInterface< CasADi::FX >* obj, std::vector<double > * x0, int x1);+void CasADi__IOInterface_CasADi__FX___setInput_TIC_TIC_TIC(CasADi::IOInterface< CasADi::FX >* obj, std::vector<double > * x0, int x1){+ std::vector<double > x0_ = Marshaling<std::vector<double >,std::vector<double > *>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);++ return obj->setInput(x0_, x1_);+}+++// ================== Normal method: "setInput''''" ===============+// class: "CasADi::IOInterface< CasADi::FX >"+// cppName: "CasADi::IOInterface< CasADi::FX >::setInput''''"+// cWrapperName: "CasADi__IOInterface_CasADi__FX___setInput_TIC_TIC_TIC_TIC"+// protoArgs: "(CasADi::IOInterface< CasADi::FX >* obj, std::vector<double > * x0)"+// args: "(x0_)"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__IOInterface_CasADi__FX___setInput_TIC_TIC_TIC_TIC(CasADi::IOInterface< CasADi::FX >* obj, std::vector<double > * x0)"+// call: "obj->setInput(x0_)"+extern "C"+ void CasADi__IOInterface_CasADi__FX___setInput_TIC_TIC_TIC_TIC(CasADi::IOInterface< CasADi::FX >* obj, std::vector<double > * x0);+void CasADi__IOInterface_CasADi__FX___setInput_TIC_TIC_TIC_TIC(CasADi::IOInterface< CasADi::FX >* obj, std::vector<double > * x0){+ std::vector<double > x0_ = Marshaling<std::vector<double >,std::vector<double > *>::marshal(x0);++ return obj->setInput(x0_);+}+++// ================== Normal method: "setOutput'''" ===============+// class: "CasADi::IOInterface< CasADi::FX >"+// cppName: "CasADi::IOInterface< CasADi::FX >::setOutput'''"+// cWrapperName: "CasADi__IOInterface_CasADi__FX___setOutput_TIC_TIC_TIC"+// protoArgs: "(CasADi::IOInterface< CasADi::FX >* obj, std::vector<double > * x0, int x1)"+// args: "(x0_, x1_)"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__IOInterface_CasADi__FX___setOutput_TIC_TIC_TIC(CasADi::IOInterface< CasADi::FX >* obj, std::vector<double > * x0, int x1)"+// call: "obj->setOutput(x0_, x1_)"+extern "C"+ void CasADi__IOInterface_CasADi__FX___setOutput_TIC_TIC_TIC(CasADi::IOInterface< CasADi::FX >* obj, std::vector<double > * x0, int x1);+void CasADi__IOInterface_CasADi__FX___setOutput_TIC_TIC_TIC(CasADi::IOInterface< CasADi::FX >* obj, std::vector<double > * x0, int x1){+ std::vector<double > x0_ = Marshaling<std::vector<double >,std::vector<double > *>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);++ return obj->setOutput(x0_, x1_);+}+++// ================== Normal method: "setOutput''''" ===============+// class: "CasADi::IOInterface< CasADi::FX >"+// cppName: "CasADi::IOInterface< CasADi::FX >::setOutput''''"+// cWrapperName: "CasADi__IOInterface_CasADi__FX___setOutput_TIC_TIC_TIC_TIC"+// protoArgs: "(CasADi::IOInterface< CasADi::FX >* obj, std::vector<double > * x0)"+// args: "(x0_)"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__IOInterface_CasADi__FX___setOutput_TIC_TIC_TIC_TIC(CasADi::IOInterface< CasADi::FX >* obj, std::vector<double > * x0)"+// call: "obj->setOutput(x0_)"+extern "C"+ void CasADi__IOInterface_CasADi__FX___setOutput_TIC_TIC_TIC_TIC(CasADi::IOInterface< CasADi::FX >* obj, std::vector<double > * x0);+void CasADi__IOInterface_CasADi__FX___setOutput_TIC_TIC_TIC_TIC(CasADi::IOInterface< CasADi::FX >* obj, std::vector<double > * x0){+ std::vector<double > x0_ = Marshaling<std::vector<double >,std::vector<double > *>::marshal(x0);++ return obj->setOutput(x0_);+}+++// ================== Normal method: "setInput'''''" ===============+// class: "CasADi::IOInterface< CasADi::FX >"+// cppName: "CasADi::IOInterface< CasADi::FX >::setInput'''''"+// cWrapperName: "CasADi__IOInterface_CasADi__FX___setInput_TIC_TIC_TIC_TIC_TIC"+// protoArgs: "(CasADi::IOInterface< CasADi::FX >* obj, std::vector<double > * x0, std::string* x1)"+// args: "(x0_, x1_)"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__IOInterface_CasADi__FX___setInput_TIC_TIC_TIC_TIC_TIC(CasADi::IOInterface< CasADi::FX >* obj, std::vector<double > * x0, std::string* x1)"+// call: "obj->setInput(x0_, x1_)"+extern "C"+ void CasADi__IOInterface_CasADi__FX___setInput_TIC_TIC_TIC_TIC_TIC(CasADi::IOInterface< CasADi::FX >* obj, std::vector<double > * x0, std::string* x1);+void CasADi__IOInterface_CasADi__FX___setInput_TIC_TIC_TIC_TIC_TIC(CasADi::IOInterface< CasADi::FX >* obj, std::vector<double > * x0, std::string* x1){+ std::vector<double > x0_ = Marshaling<std::vector<double >,std::vector<double > *>::marshal(x0);+ std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);++ return obj->setInput(x0_, x1_);+}+++// ================== Normal method: "setOutput'''''" ===============+// class: "CasADi::IOInterface< CasADi::FX >"+// cppName: "CasADi::IOInterface< CasADi::FX >::setOutput'''''"+// cWrapperName: "CasADi__IOInterface_CasADi__FX___setOutput_TIC_TIC_TIC_TIC_TIC"+// protoArgs: "(CasADi::IOInterface< CasADi::FX >* obj, std::vector<double > * x0, std::string* x1)"+// args: "(x0_, x1_)"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__IOInterface_CasADi__FX___setOutput_TIC_TIC_TIC_TIC_TIC(CasADi::IOInterface< CasADi::FX >* obj, std::vector<double > * x0, std::string* x1)"+// call: "obj->setOutput(x0_, x1_)"+extern "C"+ void CasADi__IOInterface_CasADi__FX___setOutput_TIC_TIC_TIC_TIC_TIC(CasADi::IOInterface< CasADi::FX >* obj, std::vector<double > * x0, std::string* x1);+void CasADi__IOInterface_CasADi__FX___setOutput_TIC_TIC_TIC_TIC_TIC(CasADi::IOInterface< CasADi::FX >* obj, std::vector<double > * x0, std::string* x1){+ std::vector<double > x0_ = Marshaling<std::vector<double >,std::vector<double > *>::marshal(x0);+ std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);++ return obj->setOutput(x0_, x1_);+}+++// ================== Normal method: "setInput''''''" ===============+// class: "CasADi::IOInterface< CasADi::FX >"+// cppName: "CasADi::IOInterface< CasADi::FX >::setInput''''''"+// cWrapperName: "CasADi__IOInterface_CasADi__FX___setInput_TIC_TIC_TIC_TIC_TIC_TIC"+// protoArgs: "(CasADi::IOInterface< CasADi::FX >* obj, CasADi::Matrix< double >* x0, int x1)"+// args: "(x0_, x1_)"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__IOInterface_CasADi__FX___setInput_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::IOInterface< CasADi::FX >* obj, CasADi::Matrix< double >* x0, int x1)"+// call: "obj->setInput(x0_, x1_)"+extern "C"+ void CasADi__IOInterface_CasADi__FX___setInput_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::IOInterface< CasADi::FX >* obj, CasADi::Matrix< double >* x0, int x1);+void CasADi__IOInterface_CasADi__FX___setInput_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::IOInterface< CasADi::FX >* obj, CasADi::Matrix< double >* x0, int x1){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);++ return obj->setInput(x0_, x1_);+}+++// ================== Normal method: "setInput'''''''" ===============+// class: "CasADi::IOInterface< CasADi::FX >"+// cppName: "CasADi::IOInterface< CasADi::FX >::setInput'''''''"+// cWrapperName: "CasADi__IOInterface_CasADi__FX___setInput_TIC_TIC_TIC_TIC_TIC_TIC_TIC"+// protoArgs: "(CasADi::IOInterface< CasADi::FX >* obj, CasADi::Matrix< double >* x0)"+// args: "(x0_)"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__IOInterface_CasADi__FX___setInput_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::IOInterface< CasADi::FX >* obj, CasADi::Matrix< double >* x0)"+// call: "obj->setInput(x0_)"+extern "C"+ void CasADi__IOInterface_CasADi__FX___setInput_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::IOInterface< CasADi::FX >* obj, CasADi::Matrix< double >* x0);+void CasADi__IOInterface_CasADi__FX___setInput_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::IOInterface< CasADi::FX >* obj, CasADi::Matrix< double >* x0){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);++ return obj->setInput(x0_);+}+++// ================== Normal method: "setOutput''''''" ===============+// class: "CasADi::IOInterface< CasADi::FX >"+// cppName: "CasADi::IOInterface< CasADi::FX >::setOutput''''''"+// cWrapperName: "CasADi__IOInterface_CasADi__FX___setOutput_TIC_TIC_TIC_TIC_TIC_TIC"+// protoArgs: "(CasADi::IOInterface< CasADi::FX >* obj, CasADi::Matrix< double >* x0, int x1)"+// args: "(x0_, x1_)"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__IOInterface_CasADi__FX___setOutput_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::IOInterface< CasADi::FX >* obj, CasADi::Matrix< double >* x0, int x1)"+// call: "obj->setOutput(x0_, x1_)"+extern "C"+ void CasADi__IOInterface_CasADi__FX___setOutput_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::IOInterface< CasADi::FX >* obj, CasADi::Matrix< double >* x0, int x1);+void CasADi__IOInterface_CasADi__FX___setOutput_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::IOInterface< CasADi::FX >* obj, CasADi::Matrix< double >* x0, int x1){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);++ return obj->setOutput(x0_, x1_);+}+++// ================== Normal method: "setOutput'''''''" ===============+// class: "CasADi::IOInterface< CasADi::FX >"+// cppName: "CasADi::IOInterface< CasADi::FX >::setOutput'''''''"+// cWrapperName: "CasADi__IOInterface_CasADi__FX___setOutput_TIC_TIC_TIC_TIC_TIC_TIC_TIC"+// protoArgs: "(CasADi::IOInterface< CasADi::FX >* obj, CasADi::Matrix< double >* x0)"+// args: "(x0_)"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__IOInterface_CasADi__FX___setOutput_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::IOInterface< CasADi::FX >* obj, CasADi::Matrix< double >* x0)"+// call: "obj->setOutput(x0_)"+extern "C"+ void CasADi__IOInterface_CasADi__FX___setOutput_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::IOInterface< CasADi::FX >* obj, CasADi::Matrix< double >* x0);+void CasADi__IOInterface_CasADi__FX___setOutput_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::IOInterface< CasADi::FX >* obj, CasADi::Matrix< double >* x0){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);++ return obj->setOutput(x0_);+}+++// ================== Normal method: "setInput''''''''" ===============+// class: "CasADi::IOInterface< CasADi::FX >"+// cppName: "CasADi::IOInterface< CasADi::FX >::setInput''''''''"+// cWrapperName: "CasADi__IOInterface_CasADi__FX___setInput_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"+// protoArgs: "(CasADi::IOInterface< CasADi::FX >* obj, CasADi::Matrix< double >* x0, std::string* x1)"+// args: "(x0_, x1_)"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__IOInterface_CasADi__FX___setInput_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::IOInterface< CasADi::FX >* obj, CasADi::Matrix< double >* x0, std::string* x1)"+// call: "obj->setInput(x0_, x1_)"+extern "C"+ void CasADi__IOInterface_CasADi__FX___setInput_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::IOInterface< CasADi::FX >* obj, CasADi::Matrix< double >* x0, std::string* x1);+void CasADi__IOInterface_CasADi__FX___setInput_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::IOInterface< CasADi::FX >* obj, CasADi::Matrix< double >* x0, std::string* x1){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);+ std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);++ return obj->setInput(x0_, x1_);+}+++// ================== Normal method: "setOutput''''''''" ===============+// class: "CasADi::IOInterface< CasADi::FX >"+// cppName: "CasADi::IOInterface< CasADi::FX >::setOutput''''''''"+// cWrapperName: "CasADi__IOInterface_CasADi__FX___setOutput_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"+// protoArgs: "(CasADi::IOInterface< CasADi::FX >* obj, CasADi::Matrix< double >* x0, std::string* x1)"+// args: "(x0_, x1_)"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__IOInterface_CasADi__FX___setOutput_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::IOInterface< CasADi::FX >* obj, CasADi::Matrix< double >* x0, std::string* x1)"+// call: "obj->setOutput(x0_, x1_)"+extern "C"+ void CasADi__IOInterface_CasADi__FX___setOutput_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::IOInterface< CasADi::FX >* obj, CasADi::Matrix< double >* x0, std::string* x1);+void CasADi__IOInterface_CasADi__FX___setOutput_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::IOInterface< CasADi::FX >* obj, CasADi::Matrix< double >* x0, std::string* x1){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);+ std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);++ return obj->setOutput(x0_, x1_);+}+++// ================== delete CasadiClass OptionsFunctionality===============+// classType: CasadiClass OptionsFunctionality+extern "C"+ void delete_CasADi__OptionsFunctionality(CasADi::OptionsFunctionality* obj);+void delete_CasADi__OptionsFunctionality(CasADi::OptionsFunctionality* obj){+ delete obj;+}+extern "C"+ void delete_std__vector_CasADi__OptionsFunctionality_(std::vector<CasADi::OptionsFunctionality* >* obj);+void delete_std__vector_CasADi__OptionsFunctionality_(std::vector<CasADi::OptionsFunctionality* >* obj){+ delete obj;+}+extern "C"+ void delete_std__vector_std__vector_CasADi__OptionsFunctionality__(std::vector<std::vector<CasADi::OptionsFunctionality* > >* obj);+void delete_std__vector_std__vector_CasADi__OptionsFunctionality__(std::vector<std::vector<CasADi::OptionsFunctionality* > >* obj){+ delete obj;+}+extern "C"+ void delete_std__vector_std__vector_std__vector_CasADi__OptionsFunctionality___(std::vector<std::vector<std::vector<CasADi::OptionsFunctionality* > > >* obj);+void delete_std__vector_std__vector_std__vector_CasADi__OptionsFunctionality___(std::vector<std::vector<std::vector<CasADi::OptionsFunctionality* > > >* obj){+ delete obj;+}++// ================== Normal method: "setOption" ===============+// class: "CasADi::OptionsFunctionality"+// cppName: "CasADi::OptionsFunctionality::setOption"+// cWrapperName: "CasADi__OptionsFunctionality__setOption"+// protoArgs: "(CasADi::OptionsFunctionality* obj, std::string* x0, CasADi::GenericType* x1)"+// args: "(x0_, x1_)"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__OptionsFunctionality__setOption(CasADi::OptionsFunctionality* obj, std::string* x0, CasADi::GenericType* x1)"+// call: "obj->setOption(x0_, x1_)"+extern "C"+ void CasADi__OptionsFunctionality__setOption(CasADi::OptionsFunctionality* obj, std::string* x0, CasADi::GenericType* x1);+void CasADi__OptionsFunctionality__setOption(CasADi::OptionsFunctionality* obj, std::string* x0, CasADi::GenericType* x1){+ std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);+ CasADi::GenericType x1_ = Marshaling<CasADi::GenericType,CasADi::GenericType*>::marshal(x1);++ return obj->setOption(x0_, x1_);+}+++// ================== Normal method: "getOption" ===============+// class: "CasADi::OptionsFunctionality"+// cppName: "CasADi::OptionsFunctionality::getOption"+// cWrapperName: "CasADi__OptionsFunctionality__getOption"+// protoArgs: "(CasADi::OptionsFunctionality* obj, std::string* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass GenericType))+// cWrapperRetType: "CasADi::GenericType*"+// proto: "CasADi::GenericType* CasADi__OptionsFunctionality__getOption(CasADi::OptionsFunctionality* obj, std::string* x0)"+// call: "obj->getOption(x0_)"+extern "C"+ CasADi::GenericType* CasADi__OptionsFunctionality__getOption(CasADi::OptionsFunctionality* obj, std::string* x0);+CasADi::GenericType* CasADi__OptionsFunctionality__getOption(CasADi::OptionsFunctionality* obj, std::string* x0){+ std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);++ return new CasADi::GenericType( obj->getOption(x0_) );+}+++// ================== Normal method: "hasOption" ===============+// class: "CasADi::OptionsFunctionality"+// cppName: "CasADi::OptionsFunctionality::hasOption"+// cWrapperName: "CasADi__OptionsFunctionality__hasOption"+// protoArgs: "(CasADi::OptionsFunctionality* obj, std::string* x0)"+// args: "(x0_)"+// rettype: Val (NonVec CBool)+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__OptionsFunctionality__hasOption(CasADi::OptionsFunctionality* obj, std::string* x0)"+// call: "obj->hasOption(x0_)"+extern "C"+ bool* CasADi__OptionsFunctionality__hasOption(CasADi::OptionsFunctionality* obj, std::string* x0);+bool* CasADi__OptionsFunctionality__hasOption(CasADi::OptionsFunctionality* obj, std::string* x0){+ std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);++ return new bool( obj->hasOption(x0_) );+}+++// ================== Normal method: "hasSetOption" ===============+// class: "CasADi::OptionsFunctionality"+// cppName: "CasADi::OptionsFunctionality::hasSetOption"+// cWrapperName: "CasADi__OptionsFunctionality__hasSetOption"+// protoArgs: "(CasADi::OptionsFunctionality* obj, std::string* x0)"+// args: "(x0_)"+// rettype: Val (NonVec CBool)+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__OptionsFunctionality__hasSetOption(CasADi::OptionsFunctionality* obj, std::string* x0)"+// call: "obj->hasSetOption(x0_)"+extern "C"+ bool* CasADi__OptionsFunctionality__hasSetOption(CasADi::OptionsFunctionality* obj, std::string* x0);+bool* CasADi__OptionsFunctionality__hasSetOption(CasADi::OptionsFunctionality* obj, std::string* x0){+ std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);++ return new bool( obj->hasSetOption(x0_) );+}+++// ================== Normal method: "printOptions'" ===============+// class: "CasADi::OptionsFunctionality"+// cppName: "CasADi::OptionsFunctionality::printOptions'"+// cWrapperName: "CasADi__OptionsFunctionality__printOptions_TIC"+// protoArgs: "(CasADi::OptionsFunctionality* obj)"+// args: "()"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__OptionsFunctionality__printOptions_TIC(CasADi::OptionsFunctionality* obj)"+// call: "obj->printOptions()"+extern "C"+ void CasADi__OptionsFunctionality__printOptions_TIC(CasADi::OptionsFunctionality* obj);+void CasADi__OptionsFunctionality__printOptions_TIC(CasADi::OptionsFunctionality* obj){++ return obj->printOptions();+}+++// ================== Normal method: "copyOptions" ===============+// class: "CasADi::OptionsFunctionality"+// cppName: "CasADi::OptionsFunctionality::copyOptions"+// cWrapperName: "CasADi__OptionsFunctionality__copyOptions"+// protoArgs: "(CasADi::OptionsFunctionality* obj, CasADi::OptionsFunctionality* x0, bool* x1)"+// args: "(x0_, x1_)"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__OptionsFunctionality__copyOptions(CasADi::OptionsFunctionality* obj, CasADi::OptionsFunctionality* x0, bool* x1)"+// call: "obj->copyOptions(x0_, x1_)"+extern "C"+ void CasADi__OptionsFunctionality__copyOptions(CasADi::OptionsFunctionality* obj, CasADi::OptionsFunctionality* x0, bool* x1);+void CasADi__OptionsFunctionality__copyOptions(CasADi::OptionsFunctionality* obj, CasADi::OptionsFunctionality* x0, bool* x1){+ CasADi::OptionsFunctionality x0_ = Marshaling<CasADi::OptionsFunctionality,CasADi::OptionsFunctionality*>::marshal(x0);+ bool x1_ = Marshaling<bool,bool*>::marshal(x1);++ return obj->copyOptions(x0_, x1_);+}+++// ================== Normal method: "copyOptions'" ===============+// class: "CasADi::OptionsFunctionality"+// cppName: "CasADi::OptionsFunctionality::copyOptions'"+// cWrapperName: "CasADi__OptionsFunctionality__copyOptions_TIC"+// protoArgs: "(CasADi::OptionsFunctionality* obj, CasADi::OptionsFunctionality* x0)"+// args: "(x0_)"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__OptionsFunctionality__copyOptions_TIC(CasADi::OptionsFunctionality* obj, CasADi::OptionsFunctionality* x0)"+// call: "obj->copyOptions(x0_)"+extern "C"+ void CasADi__OptionsFunctionality__copyOptions_TIC(CasADi::OptionsFunctionality* obj, CasADi::OptionsFunctionality* x0);+void CasADi__OptionsFunctionality__copyOptions_TIC(CasADi::OptionsFunctionality* obj, CasADi::OptionsFunctionality* x0){+ CasADi::OptionsFunctionality x0_ = Marshaling<CasADi::OptionsFunctionality,CasADi::OptionsFunctionality*>::marshal(x0);++ return obj->copyOptions(x0_);+}+++// ================== Normal method: "checkNode" ===============+// class: "CasADi::OptionsFunctionality"+// cppName: "CasADi::OptionsFunctionality::checkNode"+// cWrapperName: "CasADi__OptionsFunctionality__checkNode"+// protoArgs: "(CasADi::OptionsFunctionality* obj)"+// args: "()"+// rettype: Val (NonVec CBool)+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__OptionsFunctionality__checkNode(CasADi::OptionsFunctionality* obj)"+// call: "obj->checkNode()"+extern "C"+ bool* CasADi__OptionsFunctionality__checkNode(CasADi::OptionsFunctionality* obj);+bool* CasADi__OptionsFunctionality__checkNode(CasADi::OptionsFunctionality* obj){++ return new bool( obj->checkNode() );+}+++// ================== Normal method: "getOptionNames" ===============+// class: "CasADi::OptionsFunctionality"+// cppName: "CasADi::OptionsFunctionality::getOptionNames"+// cWrapperName: "CasADi__OptionsFunctionality__getOptionNames"+// protoArgs: "(CasADi::OptionsFunctionality* obj)"+// args: "()"+// rettype: Val (Vec (NonVec StdString))+// cWrapperRetType: "std::vector<std::string >*"+// proto: "std::vector<std::string >* CasADi__OptionsFunctionality__getOptionNames(CasADi::OptionsFunctionality* obj)"+// call: "obj->getOptionNames()"+extern "C"+ std::vector<std::string >* CasADi__OptionsFunctionality__getOptionNames(CasADi::OptionsFunctionality* obj);+std::vector<std::string >* CasADi__OptionsFunctionality__getOptionNames(CasADi::OptionsFunctionality* obj){++ return new std::vector<std::string >( obj->getOptionNames() );+}+++// ================== Normal method: "getOptionDescription" ===============+// class: "CasADi::OptionsFunctionality"+// cppName: "CasADi::OptionsFunctionality::getOptionDescription"+// cWrapperName: "CasADi__OptionsFunctionality__getOptionDescription"+// protoArgs: "(CasADi::OptionsFunctionality* obj, std::string* x0)"+// args: "(x0_)"+// rettype: Val (NonVec StdString)+// cWrapperRetType: "std::string*"+// proto: "std::string* CasADi__OptionsFunctionality__getOptionDescription(CasADi::OptionsFunctionality* obj, std::string* x0)"+// call: "obj->getOptionDescription(x0_)"+extern "C"+ std::string* CasADi__OptionsFunctionality__getOptionDescription(CasADi::OptionsFunctionality* obj, std::string* x0);+std::string* CasADi__OptionsFunctionality__getOptionDescription(CasADi::OptionsFunctionality* obj, std::string* x0){+ std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);++ return new std::string( obj->getOptionDescription(x0_) );+}+++// ================== Normal method: "getOptionType" ===============+// class: "CasADi::OptionsFunctionality"+// cppName: "CasADi::OptionsFunctionality::getOptionType"+// cWrapperName: "CasADi__OptionsFunctionality__getOptionType"+// protoArgs: "(CasADi::OptionsFunctionality* obj, std::string* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiEnum Opt_type))+// cWrapperRetType: "CasADi::opt_type"+// proto: "CasADi::opt_type CasADi__OptionsFunctionality__getOptionType(CasADi::OptionsFunctionality* obj, std::string* x0)"+// call: "obj->getOptionType(x0_)"+extern "C"+ CasADi::opt_type CasADi__OptionsFunctionality__getOptionType(CasADi::OptionsFunctionality* obj, std::string* x0);+CasADi::opt_type CasADi__OptionsFunctionality__getOptionType(CasADi::OptionsFunctionality* obj, std::string* x0){+ std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);++ return obj->getOptionType(x0_);+}+++// ================== Normal method: "getOptionTypeName" ===============+// class: "CasADi::OptionsFunctionality"+// cppName: "CasADi::OptionsFunctionality::getOptionTypeName"+// cWrapperName: "CasADi__OptionsFunctionality__getOptionTypeName"+// protoArgs: "(CasADi::OptionsFunctionality* obj, std::string* x0)"+// args: "(x0_)"+// rettype: Val (NonVec StdString)+// cWrapperRetType: "std::string*"+// proto: "std::string* CasADi__OptionsFunctionality__getOptionTypeName(CasADi::OptionsFunctionality* obj, std::string* x0)"+// call: "obj->getOptionTypeName(x0_)"+extern "C"+ std::string* CasADi__OptionsFunctionality__getOptionTypeName(CasADi::OptionsFunctionality* obj, std::string* x0);+std::string* CasADi__OptionsFunctionality__getOptionTypeName(CasADi::OptionsFunctionality* obj, std::string* x0){+ std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);++ return new std::string( obj->getOptionTypeName(x0_) );+}+++// ================== Normal method: "getOptionAllowed" ===============+// class: "CasADi::OptionsFunctionality"+// cppName: "CasADi::OptionsFunctionality::getOptionAllowed"+// cWrapperName: "CasADi__OptionsFunctionality__getOptionAllowed"+// protoArgs: "(CasADi::OptionsFunctionality* obj, std::string* x0)"+// args: "(x0_)"+// rettype: Val (Vec (NonVec (CasadiClass GenericType)))+// cWrapperRetType: "std::vector<CasADi::GenericType >*"+// proto: "std::vector<CasADi::GenericType >* CasADi__OptionsFunctionality__getOptionAllowed(CasADi::OptionsFunctionality* obj, std::string* x0)"+// call: "obj->getOptionAllowed(x0_)"+extern "C"+ std::vector<CasADi::GenericType >* CasADi__OptionsFunctionality__getOptionAllowed(CasADi::OptionsFunctionality* obj, std::string* x0);+std::vector<CasADi::GenericType >* CasADi__OptionsFunctionality__getOptionAllowed(CasADi::OptionsFunctionality* obj, std::string* x0){+ std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);++ return new std::vector<CasADi::GenericType >( obj->getOptionAllowed(x0_) );+}+++// ================== Normal method: "getOptionAllowedIndex" ===============+// class: "CasADi::OptionsFunctionality"+// cppName: "CasADi::OptionsFunctionality::getOptionAllowedIndex"+// cWrapperName: "CasADi__OptionsFunctionality__getOptionAllowedIndex"+// protoArgs: "(CasADi::OptionsFunctionality* obj, std::string* x0)"+// args: "(x0_)"+// rettype: Val (NonVec CInt)+// cWrapperRetType: "int"+// proto: "int CasADi__OptionsFunctionality__getOptionAllowedIndex(CasADi::OptionsFunctionality* obj, std::string* x0)"+// call: "obj->getOptionAllowedIndex(x0_)"+extern "C"+ int CasADi__OptionsFunctionality__getOptionAllowedIndex(CasADi::OptionsFunctionality* obj, std::string* x0);+int CasADi__OptionsFunctionality__getOptionAllowedIndex(CasADi::OptionsFunctionality* obj, std::string* x0){+ std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);++ return obj->getOptionAllowedIndex(x0_);+}+++// ================== Normal method: "setOptionByAllowedIndex" ===============+// class: "CasADi::OptionsFunctionality"+// cppName: "CasADi::OptionsFunctionality::setOptionByAllowedIndex"+// cWrapperName: "CasADi__OptionsFunctionality__setOptionByAllowedIndex"+// protoArgs: "(CasADi::OptionsFunctionality* obj, std::string* x0, int x1)"+// args: "(x0_, x1_)"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__OptionsFunctionality__setOptionByAllowedIndex(CasADi::OptionsFunctionality* obj, std::string* x0, int x1)"+// call: "obj->setOptionByAllowedIndex(x0_, x1_)"+extern "C"+ void CasADi__OptionsFunctionality__setOptionByAllowedIndex(CasADi::OptionsFunctionality* obj, std::string* x0, int x1);+void CasADi__OptionsFunctionality__setOptionByAllowedIndex(CasADi::OptionsFunctionality* obj, std::string* x0, int x1){+ std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);++ return obj->setOptionByAllowedIndex(x0_, x1_);+}+++// ================== Normal method: "getOptionEnumValue" ===============+// class: "CasADi::OptionsFunctionality"+// cppName: "CasADi::OptionsFunctionality::getOptionEnumValue"+// cWrapperName: "CasADi__OptionsFunctionality__getOptionEnumValue"+// protoArgs: "(CasADi::OptionsFunctionality* obj, std::string* x0)"+// args: "(x0_)"+// rettype: Val (NonVec CInt)+// cWrapperRetType: "int"+// proto: "int CasADi__OptionsFunctionality__getOptionEnumValue(CasADi::OptionsFunctionality* obj, std::string* x0)"+// call: "obj->getOptionEnumValue(x0_)"+extern "C"+ int CasADi__OptionsFunctionality__getOptionEnumValue(CasADi::OptionsFunctionality* obj, std::string* x0);+int CasADi__OptionsFunctionality__getOptionEnumValue(CasADi::OptionsFunctionality* obj, std::string* x0){+ std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);++ return obj->getOptionEnumValue(x0_);+}+++// ================== Normal method: "setOptionByEnumValue" ===============+// class: "CasADi::OptionsFunctionality"+// cppName: "CasADi::OptionsFunctionality::setOptionByEnumValue"+// cWrapperName: "CasADi__OptionsFunctionality__setOptionByEnumValue"+// protoArgs: "(CasADi::OptionsFunctionality* obj, std::string* x0, int x1)"+// args: "(x0_, x1_)"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__OptionsFunctionality__setOptionByEnumValue(CasADi::OptionsFunctionality* obj, std::string* x0, int x1)"+// call: "obj->setOptionByEnumValue(x0_, x1_)"+extern "C"+ void CasADi__OptionsFunctionality__setOptionByEnumValue(CasADi::OptionsFunctionality* obj, std::string* x0, int x1);+void CasADi__OptionsFunctionality__setOptionByEnumValue(CasADi::OptionsFunctionality* obj, std::string* x0, int x1){+ std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);++ return obj->setOptionByEnumValue(x0_, x1_);+}+++// ================== Normal method: "getOptionDefault" ===============+// class: "CasADi::OptionsFunctionality"+// cppName: "CasADi::OptionsFunctionality::getOptionDefault"+// cWrapperName: "CasADi__OptionsFunctionality__getOptionDefault"+// protoArgs: "(CasADi::OptionsFunctionality* obj, std::string* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass GenericType))+// cWrapperRetType: "CasADi::GenericType*"+// proto: "CasADi::GenericType* CasADi__OptionsFunctionality__getOptionDefault(CasADi::OptionsFunctionality* obj, std::string* x0)"+// call: "obj->getOptionDefault(x0_)"+extern "C"+ CasADi::GenericType* CasADi__OptionsFunctionality__getOptionDefault(CasADi::OptionsFunctionality* obj, std::string* x0);+CasADi::GenericType* CasADi__OptionsFunctionality__getOptionDefault(CasADi::OptionsFunctionality* obj, std::string* x0){+ std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);++ return new CasADi::GenericType( obj->getOptionDefault(x0_) );+}+++// ================== Constructor method: "OptionsFunctionality" ===============+// class: "CasADi::OptionsFunctionality"+// cppName: "CasADi::OptionsFunctionality"+// cWrapperName: "CasADi__OptionsFunctionality__OptionsFunctionality"+// protoArgs: "()"+// args: "()"+// rettype: Val (NonVec (CasadiClass OptionsFunctionality))+// cWrapperRetType: "CasADi::OptionsFunctionality*"+// proto: "CasADi::OptionsFunctionality* CasADi__OptionsFunctionality__OptionsFunctionality()"+// call: "CasADi::OptionsFunctionality()"+extern "C"+ CasADi::OptionsFunctionality* CasADi__OptionsFunctionality__OptionsFunctionality();+CasADi::OptionsFunctionality* CasADi__OptionsFunctionality__OptionsFunctionality(){++ return new CasADi::OptionsFunctionality( CasADi::OptionsFunctionality() );+}+++// ================== delete CasadiClass IpoptSolver===============+// classType: CasadiClass IpoptSolver+extern "C"+ void delete_CasADi__IpoptSolver(CasADi::IpoptSolver* obj);+void delete_CasADi__IpoptSolver(CasADi::IpoptSolver* obj){+ delete obj;+}+extern "C"+ void delete_std__vector_CasADi__IpoptSolver_(std::vector<CasADi::IpoptSolver* >* obj);+void delete_std__vector_CasADi__IpoptSolver_(std::vector<CasADi::IpoptSolver* >* obj){+ delete obj;+}+extern "C"+ void delete_std__vector_std__vector_CasADi__IpoptSolver__(std::vector<std::vector<CasADi::IpoptSolver* > >* obj);+void delete_std__vector_std__vector_CasADi__IpoptSolver__(std::vector<std::vector<CasADi::IpoptSolver* > >* obj){+ delete obj;+}+extern "C"+ void delete_std__vector_std__vector_std__vector_CasADi__IpoptSolver___(std::vector<std::vector<std::vector<CasADi::IpoptSolver* > > >* obj);+void delete_std__vector_std__vector_std__vector_CasADi__IpoptSolver___(std::vector<std::vector<std::vector<CasADi::IpoptSolver* > > >* obj){+ delete obj;+}++// ================== Normal method: "getReducedHessian" ===============+// class: "CasADi::IpoptSolver"+// cppName: "CasADi::IpoptSolver::getReducedHessian"+// cWrapperName: "CasADi__IpoptSolver__getReducedHessian"+// protoArgs: "(CasADi::IpoptSolver* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass DMatrix))+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__IpoptSolver__getReducedHessian(CasADi::IpoptSolver* obj)"+// call: "obj->getReducedHessian()"+extern "C"+ CasADi::Matrix< double >* CasADi__IpoptSolver__getReducedHessian(CasADi::IpoptSolver* obj);+CasADi::Matrix< double >* CasADi__IpoptSolver__getReducedHessian(CasADi::IpoptSolver* obj){++ return new CasADi::Matrix< double >( obj->getReducedHessian() );+}+++// ================== Normal method: "checkNode" ===============+// class: "CasADi::IpoptSolver"+// cppName: "CasADi::IpoptSolver::checkNode"+// cWrapperName: "CasADi__IpoptSolver__checkNode"+// protoArgs: "(CasADi::IpoptSolver* obj)"+// args: "()"+// rettype: Val (NonVec CBool)+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__IpoptSolver__checkNode(CasADi::IpoptSolver* obj)"+// call: "obj->checkNode()"+extern "C"+ bool* CasADi__IpoptSolver__checkNode(CasADi::IpoptSolver* obj);+bool* CasADi__IpoptSolver__checkNode(CasADi::IpoptSolver* obj){++ return new bool( obj->checkNode() );+}+++// ================== Constructor method: "IpoptSolver" ===============+// class: "CasADi::IpoptSolver"+// cppName: "CasADi::IpoptSolver"+// cWrapperName: "CasADi__IpoptSolver__IpoptSolver"+// protoArgs: "()"+// args: "()"+// rettype: Val (NonVec (CasadiClass IpoptSolver))+// cWrapperRetType: "CasADi::IpoptSolver*"+// proto: "CasADi::IpoptSolver* CasADi__IpoptSolver__IpoptSolver()"+// call: "CasADi::IpoptSolver()"+extern "C"+ CasADi::IpoptSolver* CasADi__IpoptSolver__IpoptSolver();+CasADi::IpoptSolver* CasADi__IpoptSolver__IpoptSolver(){++ return new CasADi::IpoptSolver( CasADi::IpoptSolver() );+}+++// ================== Constructor method: "IpoptSolver'" ===============+// class: "CasADi::IpoptSolver"+// cppName: "CasADi::IpoptSolver"+// cWrapperName: "CasADi__IpoptSolver__IpoptSolver_TIC"+// protoArgs: "(CasADi::FX* x0, CasADi::FX* x1)"+// args: "(x0_, x1_)"+// rettype: Val (NonVec (CasadiClass IpoptSolver))+// cWrapperRetType: "CasADi::IpoptSolver*"+// proto: "CasADi::IpoptSolver* CasADi__IpoptSolver__IpoptSolver_TIC(CasADi::FX* x0, CasADi::FX* x1)"+// call: "CasADi::IpoptSolver(x0_, x1_)"+extern "C"+ CasADi::IpoptSolver* CasADi__IpoptSolver__IpoptSolver_TIC(CasADi::FX* x0, CasADi::FX* x1);+CasADi::IpoptSolver* CasADi__IpoptSolver__IpoptSolver_TIC(CasADi::FX* x0, CasADi::FX* x1){+ CasADi::FX x0_ = Marshaling<CasADi::FX,CasADi::FX*>::marshal(x0);+ CasADi::FX x1_ = Marshaling<CasADi::FX,CasADi::FX*>::marshal(x1);++ return new CasADi::IpoptSolver( CasADi::IpoptSolver(x0_, x1_) );+}+++// ================== Constructor method: "IpoptSolver''" ===============+// class: "CasADi::IpoptSolver"+// cppName: "CasADi::IpoptSolver"+// cWrapperName: "CasADi__IpoptSolver__IpoptSolver_TIC_TIC"+// protoArgs: "(CasADi::FX* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass IpoptSolver))+// cWrapperRetType: "CasADi::IpoptSolver*"+// proto: "CasADi::IpoptSolver* CasADi__IpoptSolver__IpoptSolver_TIC_TIC(CasADi::FX* x0)"+// call: "CasADi::IpoptSolver(x0_)"+extern "C"+ CasADi::IpoptSolver* CasADi__IpoptSolver__IpoptSolver_TIC_TIC(CasADi::FX* x0);+CasADi::IpoptSolver* CasADi__IpoptSolver__IpoptSolver_TIC_TIC(CasADi::FX* x0){+ CasADi::FX x0_ = Marshaling<CasADi::FX,CasADi::FX*>::marshal(x0);++ return new CasADi::IpoptSolver( CasADi::IpoptSolver(x0_) );+}+++// ================== delete CasadiClass SXMatrix===============+// classType: CasadiClass SXMatrix+extern "C"+ void delete_CasADi__Matrix_CasADi__SX_(CasADi::Matrix< CasADi::SX >* obj);+void delete_CasADi__Matrix_CasADi__SX_(CasADi::Matrix< CasADi::SX >* obj){+ delete obj;+}+extern "C"+ void delete_std__vector_CasADi__Matrix_CasADi__SX__(std::vector<CasADi::Matrix< CasADi::SX >* >* obj);+void delete_std__vector_CasADi__Matrix_CasADi__SX__(std::vector<CasADi::Matrix< CasADi::SX >* >* obj){+ delete obj;+}+extern "C"+ void delete_std__vector_std__vector_CasADi__Matrix_CasADi__SX___(std::vector<std::vector<CasADi::Matrix< CasADi::SX >* > >* obj);+void delete_std__vector_std__vector_CasADi__Matrix_CasADi__SX___(std::vector<std::vector<CasADi::Matrix< CasADi::SX >* > >* obj){+ delete obj;+}+extern "C"+ void delete_std__vector_std__vector_std__vector_CasADi__Matrix_CasADi__SX____(std::vector<std::vector<std::vector<CasADi::Matrix< CasADi::SX >* > > >* obj);+void delete_std__vector_std__vector_std__vector_CasADi__Matrix_CasADi__SX____(std::vector<std::vector<std::vector<CasADi::Matrix< CasADi::SX >* > > >* obj){+ delete obj;+}++// ================== Normal method: "size1" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::size1"+// cWrapperName: "CasADi__Matrix_CasADi__SX___size1"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj)"+// args: "()"+// rettype: Val (NonVec CInt)+// cWrapperRetType: "int"+// proto: "int CasADi__Matrix_CasADi__SX___size1(CasADi::Matrix< CasADi::SX >* obj)"+// call: "obj->size1()"+extern "C"+ int CasADi__Matrix_CasADi__SX___size1(CasADi::Matrix< CasADi::SX >* obj);+int CasADi__Matrix_CasADi__SX___size1(CasADi::Matrix< CasADi::SX >* obj){++ return obj->size1();+}+++// ================== Normal method: "size2" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::size2"+// cWrapperName: "CasADi__Matrix_CasADi__SX___size2"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj)"+// args: "()"+// rettype: Val (NonVec CInt)+// cWrapperRetType: "int"+// proto: "int CasADi__Matrix_CasADi__SX___size2(CasADi::Matrix< CasADi::SX >* obj)"+// call: "obj->size2()"+extern "C"+ int CasADi__Matrix_CasADi__SX___size2(CasADi::Matrix< CasADi::SX >* obj);+int CasADi__Matrix_CasADi__SX___size2(CasADi::Matrix< CasADi::SX >* obj){++ return obj->size2();+}+++// ================== Normal method: "size" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::size"+// cWrapperName: "CasADi__Matrix_CasADi__SX___size"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj)"+// args: "()"+// rettype: Val (NonVec CInt)+// cWrapperRetType: "int"+// proto: "int CasADi__Matrix_CasADi__SX___size(CasADi::Matrix< CasADi::SX >* obj)"+// call: "obj->size()"+extern "C"+ int CasADi__Matrix_CasADi__SX___size(CasADi::Matrix< CasADi::SX >* obj);+int CasADi__Matrix_CasADi__SX___size(CasADi::Matrix< CasADi::SX >* obj){++ return obj->size();+}+++// ================== Normal method: "numel" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::numel"+// cWrapperName: "CasADi__Matrix_CasADi__SX___numel"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj)"+// args: "()"+// rettype: Val (NonVec CInt)+// cWrapperRetType: "int"+// proto: "int CasADi__Matrix_CasADi__SX___numel(CasADi::Matrix< CasADi::SX >* obj)"+// call: "obj->numel()"+extern "C"+ int CasADi__Matrix_CasADi__SX___numel(CasADi::Matrix< CasADi::SX >* obj);+int CasADi__Matrix_CasADi__SX___numel(CasADi::Matrix< CasADi::SX >* obj){++ return obj->numel();+}+++// ================== Normal method: "sanityCheck" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::sanityCheck"+// cWrapperName: "CasADi__Matrix_CasADi__SX___sanityCheck"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj, bool* x0)"+// args: "(x0_)"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__Matrix_CasADi__SX___sanityCheck(CasADi::Matrix< CasADi::SX >* obj, bool* x0)"+// call: "obj->sanityCheck(x0_)"+extern "C"+ void CasADi__Matrix_CasADi__SX___sanityCheck(CasADi::Matrix< CasADi::SX >* obj, bool* x0);+void CasADi__Matrix_CasADi__SX___sanityCheck(CasADi::Matrix< CasADi::SX >* obj, bool* x0){+ bool x0_ = Marshaling<bool,bool*>::marshal(x0);++ return obj->sanityCheck(x0_);+}+++// ================== Normal method: "sanityCheck'" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::sanityCheck'"+// cWrapperName: "CasADi__Matrix_CasADi__SX___sanityCheck_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj)"+// args: "()"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__Matrix_CasADi__SX___sanityCheck_TIC(CasADi::Matrix< CasADi::SX >* obj)"+// call: "obj->sanityCheck()"+extern "C"+ void CasADi__Matrix_CasADi__SX___sanityCheck_TIC(CasADi::Matrix< CasADi::SX >* obj);+void CasADi__Matrix_CasADi__SX___sanityCheck_TIC(CasADi::Matrix< CasADi::SX >* obj){++ return obj->sanityCheck();+}+++// ================== Normal method: "vector" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::vector"+// cWrapperName: "CasADi__Matrix_CasADi__SX___vector"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj)"+// args: "()"+// rettype: Val (NonVec CBool)+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__Matrix_CasADi__SX___vector(CasADi::Matrix< CasADi::SX >* obj)"+// call: "obj->vector()"+extern "C"+ bool* CasADi__Matrix_CasADi__SX___vector(CasADi::Matrix< CasADi::SX >* obj);+bool* CasADi__Matrix_CasADi__SX___vector(CasADi::Matrix< CasADi::SX >* obj){++ return new bool( obj->vector() );+}+++// ================== Normal method: "at" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::at"+// cWrapperName: "CasADi__Matrix_CasADi__SX___at"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj, int x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass SX))+// cWrapperRetType: "CasADi::SX*"+// proto: "CasADi::SX* CasADi__Matrix_CasADi__SX___at(CasADi::Matrix< CasADi::SX >* obj, int x0)"+// call: "obj->at(x0_)"+extern "C"+ CasADi::SX* CasADi__Matrix_CasADi__SX___at(CasADi::Matrix< CasADi::SX >* obj, int x0);+CasADi::SX* CasADi__Matrix_CasADi__SX___at(CasADi::Matrix< CasADi::SX >* obj, int x0){+ int x0_ = Marshaling<int,int>::marshal(x0);++ return new CasADi::SX( obj->at(x0_) );+}+++// ================== Normal method: "elem" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::elem"+// cWrapperName: "CasADi__Matrix_CasADi__SX___elem"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj, int x0, int x1)"+// args: "(x0_, x1_)"+// rettype: Val (NonVec (CasadiClass SX))+// cWrapperRetType: "CasADi::SX*"+// proto: "CasADi::SX* CasADi__Matrix_CasADi__SX___elem(CasADi::Matrix< CasADi::SX >* obj, int x0, int x1)"+// call: "obj->elem(x0_, x1_)"+extern "C"+ CasADi::SX* CasADi__Matrix_CasADi__SX___elem(CasADi::Matrix< CasADi::SX >* obj, int x0, int x1);+CasADi::SX* CasADi__Matrix_CasADi__SX___elem(CasADi::Matrix< CasADi::SX >* obj, int x0, int x1){+ int x0_ = Marshaling<int,int>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);++ return new CasADi::SX( obj->elem(x0_, x1_) );+}+++// ================== Normal method: "elem'" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::elem'"+// cWrapperName: "CasADi__Matrix_CasADi__SX___elem_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj, int x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass SX))+// cWrapperRetType: "CasADi::SX*"+// proto: "CasADi::SX* CasADi__Matrix_CasADi__SX___elem_TIC(CasADi::Matrix< CasADi::SX >* obj, int x0)"+// call: "obj->elem(x0_)"+extern "C"+ CasADi::SX* CasADi__Matrix_CasADi__SX___elem_TIC(CasADi::Matrix< CasADi::SX >* obj, int x0);+CasADi::SX* CasADi__Matrix_CasADi__SX___elem_TIC(CasADi::Matrix< CasADi::SX >* obj, int x0){+ int x0_ = Marshaling<int,int>::marshal(x0);++ return new CasADi::SX( obj->elem(x0_) );+}+++// ================== Normal method: "hasNZ" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::hasNZ"+// cWrapperName: "CasADi__Matrix_CasADi__SX___hasNZ"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj, int x0, int x1)"+// args: "(x0_, x1_)"+// rettype: Val (NonVec CBool)+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__Matrix_CasADi__SX___hasNZ(CasADi::Matrix< CasADi::SX >* obj, int x0, int x1)"+// call: "obj->hasNZ(x0_, x1_)"+extern "C"+ bool* CasADi__Matrix_CasADi__SX___hasNZ(CasADi::Matrix< CasADi::SX >* obj, int x0, int x1);+bool* CasADi__Matrix_CasADi__SX___hasNZ(CasADi::Matrix< CasADi::SX >* obj, int x0, int x1){+ int x0_ = Marshaling<int,int>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);++ return new bool( obj->hasNZ(x0_, x1_) );+}+++// ================== Normal method: "__nonzero__" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::__nonzero__"+// cWrapperName: "CasADi__Matrix_CasADi__SX_____nonzero__"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj)"+// args: "()"+// rettype: Val (NonVec CBool)+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__Matrix_CasADi__SX_____nonzero__(CasADi::Matrix< CasADi::SX >* obj)"+// call: "obj->__nonzero__()"+extern "C"+ bool* CasADi__Matrix_CasADi__SX_____nonzero__(CasADi::Matrix< CasADi::SX >* obj);+bool* CasADi__Matrix_CasADi__SX_____nonzero__(CasADi::Matrix< CasADi::SX >* obj){++ return new bool( obj->__nonzero__() );+}+++// ================== Normal method: "append" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::append"+// cWrapperName: "CasADi__Matrix_CasADi__SX___append"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0)"+// args: "(x0_)"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__Matrix_CasADi__SX___append(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0)"+// call: "obj->append(x0_)"+extern "C"+ void CasADi__Matrix_CasADi__SX___append(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0);+void CasADi__Matrix_CasADi__SX___append(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);++ return obj->append(x0_);+}+++// ================== Normal method: "operator +" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::operator +"+// cWrapperName: "CasADi__Matrix_CasADi__SX___operator_plus"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass SXMatrix))+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___operator_plus(CasADi::Matrix< CasADi::SX >* obj)"+// call: "obj->operator +()"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___operator_plus(CasADi::Matrix< CasADi::SX >* obj);+CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___operator_plus(CasADi::Matrix< CasADi::SX >* obj){++ return new CasADi::Matrix< CasADi::SX >( obj->operator +() );+}+++// ================== Normal method: "operator -" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::operator -"+// cWrapperName: "CasADi__Matrix_CasADi__SX___operator_minus"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass SXMatrix))+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___operator_minus(CasADi::Matrix< CasADi::SX >* obj)"+// call: "obj->operator -()"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___operator_minus(CasADi::Matrix< CasADi::SX >* obj);+CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___operator_minus(CasADi::Matrix< CasADi::SX >* obj){++ return new CasADi::Matrix< CasADi::SX >( obj->operator -() );+}+++// ================== Static method: "binary" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::binary"+// cWrapperName: "CasADi__Matrix_CasADi__SX___binary"+// protoArgs: "(int x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2)"+// args: "(x0_, x1_, x2_)"+// rettype: Val (NonVec (CasadiClass SXMatrix))+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___binary(int x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2)"+// call: "CasADi::Matrix< CasADi::SX >::binary(x0_, x1_, x2_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___binary(int x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2);+CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___binary(int x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2){+ int x0_ = Marshaling<int,int>::marshal(x0);+ CasADi::Matrix< CasADi::SX > x1_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x1);+ CasADi::Matrix< CasADi::SX > x2_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x2);++ return new CasADi::Matrix< CasADi::SX >( CasADi::Matrix< CasADi::SX >::binary(x0_, x1_, x2_) );+}+++// ================== Static method: "unary" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::unary"+// cWrapperName: "CasADi__Matrix_CasADi__SX___unary"+// protoArgs: "(int x0, CasADi::Matrix< CasADi::SX >* x1)"+// args: "(x0_, x1_)"+// rettype: Val (NonVec (CasadiClass SXMatrix))+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___unary(int x0, CasADi::Matrix< CasADi::SX >* x1)"+// call: "CasADi::Matrix< CasADi::SX >::unary(x0_, x1_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___unary(int x0, CasADi::Matrix< CasADi::SX >* x1);+CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___unary(int x0, CasADi::Matrix< CasADi::SX >* x1){+ int x0_ = Marshaling<int,int>::marshal(x0);+ CasADi::Matrix< CasADi::SX > x1_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x1);++ return new CasADi::Matrix< CasADi::SX >( CasADi::Matrix< CasADi::SX >::unary(x0_, x1_) );+}+++// ================== Static method: "scalar_matrix" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::scalar_matrix"+// cWrapperName: "CasADi__Matrix_CasADi__SX___scalar_matrix"+// protoArgs: "(int x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2)"+// args: "(x0_, x1_, x2_)"+// rettype: Val (NonVec (CasadiClass SXMatrix))+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___scalar_matrix(int x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2)"+// call: "CasADi::Matrix< CasADi::SX >::scalar_matrix(x0_, x1_, x2_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___scalar_matrix(int x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2);+CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___scalar_matrix(int x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2){+ int x0_ = Marshaling<int,int>::marshal(x0);+ CasADi::Matrix< CasADi::SX > x1_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x1);+ CasADi::Matrix< CasADi::SX > x2_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x2);++ return new CasADi::Matrix< CasADi::SX >( CasADi::Matrix< CasADi::SX >::scalar_matrix(x0_, x1_, x2_) );+}+++// ================== Static method: "matrix_scalar" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::matrix_scalar"+// cWrapperName: "CasADi__Matrix_CasADi__SX___matrix_scalar"+// protoArgs: "(int x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2)"+// args: "(x0_, x1_, x2_)"+// rettype: Val (NonVec (CasadiClass SXMatrix))+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___matrix_scalar(int x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2)"+// call: "CasADi::Matrix< CasADi::SX >::matrix_scalar(x0_, x1_, x2_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___matrix_scalar(int x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2);+CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___matrix_scalar(int x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2){+ int x0_ = Marshaling<int,int>::marshal(x0);+ CasADi::Matrix< CasADi::SX > x1_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x1);+ CasADi::Matrix< CasADi::SX > x2_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x2);++ return new CasADi::Matrix< CasADi::SX >( CasADi::Matrix< CasADi::SX >::matrix_scalar(x0_, x1_, x2_) );+}+++// ================== Static method: "matrix_matrix" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::matrix_matrix"+// cWrapperName: "CasADi__Matrix_CasADi__SX___matrix_matrix"+// protoArgs: "(int x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2)"+// args: "(x0_, x1_, x2_)"+// rettype: Val (NonVec (CasadiClass SXMatrix))+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___matrix_matrix(int x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2)"+// call: "CasADi::Matrix< CasADi::SX >::matrix_matrix(x0_, x1_, x2_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___matrix_matrix(int x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2);+CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___matrix_matrix(int x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2){+ int x0_ = Marshaling<int,int>::marshal(x0);+ CasADi::Matrix< CasADi::SX > x1_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x1);+ CasADi::Matrix< CasADi::SX > x2_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x2);++ return new CasADi::Matrix< CasADi::SX >( CasADi::Matrix< CasADi::SX >::matrix_matrix(x0_, x1_, x2_) );+}+++// ================== Normal method: "__add__" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::__add__"+// cWrapperName: "CasADi__Matrix_CasADi__SX_____add__"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass SXMatrix))+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX_____add__(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0)"+// call: "obj->__add__(x0_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX_____add__(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0);+CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX_____add__(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);++ return new CasADi::Matrix< CasADi::SX >( obj->__add__(x0_) );+}+++// ================== Normal method: "__sub__" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::__sub__"+// cWrapperName: "CasADi__Matrix_CasADi__SX_____sub__"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass SXMatrix))+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX_____sub__(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0)"+// call: "obj->__sub__(x0_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX_____sub__(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0);+CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX_____sub__(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);++ return new CasADi::Matrix< CasADi::SX >( obj->__sub__(x0_) );+}+++// ================== Normal method: "__mul__" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::__mul__"+// cWrapperName: "CasADi__Matrix_CasADi__SX_____mul__"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass SXMatrix))+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX_____mul__(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0)"+// call: "obj->__mul__(x0_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX_____mul__(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0);+CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX_____mul__(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);++ return new CasADi::Matrix< CasADi::SX >( obj->__mul__(x0_) );+}+++// ================== Normal method: "__div__" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::__div__"+// cWrapperName: "CasADi__Matrix_CasADi__SX_____div__"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass SXMatrix))+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX_____div__(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0)"+// call: "obj->__div__(x0_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX_____div__(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0);+CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX_____div__(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);++ return new CasADi::Matrix< CasADi::SX >( obj->__div__(x0_) );+}+++// ================== Normal method: "__lt__" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::__lt__"+// cWrapperName: "CasADi__Matrix_CasADi__SX_____lt__"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass SXMatrix))+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX_____lt__(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0)"+// call: "obj->__lt__(x0_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX_____lt__(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0);+CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX_____lt__(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);++ return new CasADi::Matrix< CasADi::SX >( obj->__lt__(x0_) );+}+++// ================== Normal method: "__le__" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::__le__"+// cWrapperName: "CasADi__Matrix_CasADi__SX_____le__"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass SXMatrix))+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX_____le__(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0)"+// call: "obj->__le__(x0_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX_____le__(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0);+CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX_____le__(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);++ return new CasADi::Matrix< CasADi::SX >( obj->__le__(x0_) );+}+++// ================== Normal method: "__eq__" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::__eq__"+// cWrapperName: "CasADi__Matrix_CasADi__SX_____eq__"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass SXMatrix))+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX_____eq__(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0)"+// call: "obj->__eq__(x0_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX_____eq__(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0);+CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX_____eq__(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);++ return new CasADi::Matrix< CasADi::SX >( obj->__eq__(x0_) );+}+++// ================== Normal method: "__ne__" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::__ne__"+// cWrapperName: "CasADi__Matrix_CasADi__SX_____ne__"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass SXMatrix))+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX_____ne__(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0)"+// call: "obj->__ne__(x0_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX_____ne__(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0);+CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX_____ne__(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);++ return new CasADi::Matrix< CasADi::SX >( obj->__ne__(x0_) );+}+++// ================== Normal method: "__truediv__" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::__truediv__"+// cWrapperName: "CasADi__Matrix_CasADi__SX_____truediv__"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass SXMatrix))+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX_____truediv__(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0)"+// call: "obj->__truediv__(x0_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX_____truediv__(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0);+CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX_____truediv__(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);++ return new CasADi::Matrix< CasADi::SX >( obj->__truediv__(x0_) );+}+++// ================== Normal method: "__pow__" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::__pow__"+// cWrapperName: "CasADi__Matrix_CasADi__SX_____pow__"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass SXMatrix))+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX_____pow__(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0)"+// call: "obj->__pow__(x0_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX_____pow__(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0);+CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX_____pow__(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);++ return new CasADi::Matrix< CasADi::SX >( obj->__pow__(x0_) );+}+++// ================== Normal method: "__constpow__" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::__constpow__"+// cWrapperName: "CasADi__Matrix_CasADi__SX_____constpow__"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass SXMatrix))+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX_____constpow__(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0)"+// call: "obj->__constpow__(x0_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX_____constpow__(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0);+CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX_____constpow__(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);++ return new CasADi::Matrix< CasADi::SX >( obj->__constpow__(x0_) );+}+++// ================== Normal method: "__mpower__" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::__mpower__"+// cWrapperName: "CasADi__Matrix_CasADi__SX_____mpower__"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass SXMatrix))+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX_____mpower__(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0)"+// call: "obj->__mpower__(x0_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX_____mpower__(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0);+CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX_____mpower__(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);++ return new CasADi::Matrix< CasADi::SX >( obj->__mpower__(x0_) );+}+++// ================== Normal method: "__mrdivide__" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::__mrdivide__"+// cWrapperName: "CasADi__Matrix_CasADi__SX_____mrdivide__"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass SXMatrix))+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX_____mrdivide__(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0)"+// call: "obj->__mrdivide__(x0_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX_____mrdivide__(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0);+CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX_____mrdivide__(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);++ return new CasADi::Matrix< CasADi::SX >( obj->__mrdivide__(x0_) );+}+++// ================== Normal method: "mul_full" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::mul_full"+// cWrapperName: "CasADi__Matrix_CasADi__SX___mul_full"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0, CasADi::CRSSparsity* x1)"+// args: "(x0_, x1_)"+// rettype: Val (NonVec (CasadiClass SXMatrix))+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___mul_full(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0, CasADi::CRSSparsity* x1)"+// call: "obj->mul_full(x0_, x1_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___mul_full(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0, CasADi::CRSSparsity* x1);+CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___mul_full(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0, CasADi::CRSSparsity* x1){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);+ CasADi::CRSSparsity x1_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x1);++ return new CasADi::Matrix< CasADi::SX >( obj->mul_full(x0_, x1_) );+}+++// ================== Normal method: "mul_full'" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::mul_full'"+// cWrapperName: "CasADi__Matrix_CasADi__SX___mul_full_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass SXMatrix))+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___mul_full_TIC(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0)"+// call: "obj->mul_full(x0_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___mul_full_TIC(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0);+CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___mul_full_TIC(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);++ return new CasADi::Matrix< CasADi::SX >( obj->mul_full(x0_) );+}+++// ================== Normal method: "mul" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::mul"+// cWrapperName: "CasADi__Matrix_CasADi__SX___mul"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0, CasADi::CRSSparsity* x1)"+// args: "(x0_, x1_)"+// rettype: Val (NonVec (CasadiClass SXMatrix))+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___mul(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0, CasADi::CRSSparsity* x1)"+// call: "obj->mul(x0_, x1_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___mul(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0, CasADi::CRSSparsity* x1);+CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___mul(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0, CasADi::CRSSparsity* x1){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);+ CasADi::CRSSparsity x1_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x1);++ return new CasADi::Matrix< CasADi::SX >( obj->mul(x0_, x1_) );+}+++// ================== Normal method: "mul'" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::mul'"+// cWrapperName: "CasADi__Matrix_CasADi__SX___mul_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass SXMatrix))+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___mul_TIC(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0)"+// call: "obj->mul(x0_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___mul_TIC(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0);+CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___mul_TIC(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);++ return new CasADi::Matrix< CasADi::SX >( obj->mul(x0_) );+}+++// ================== Static method: "mul_no_alloc_nn" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::mul_no_alloc_nn"+// cWrapperName: "CasADi__Matrix_CasADi__SX___mul_no_alloc_nn"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2)"+// args: "(x0_, x1_, x2_)"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__Matrix_CasADi__SX___mul_no_alloc_nn(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2)"+// call: "CasADi::Matrix< CasADi::SX >::mul_no_alloc_nn(x0_, x1_, x2_)"+extern "C"+ void CasADi__Matrix_CasADi__SX___mul_no_alloc_nn(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2);+void CasADi__Matrix_CasADi__SX___mul_no_alloc_nn(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);+ CasADi::Matrix< CasADi::SX > x1_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x1);+ CasADi::Matrix< CasADi::SX > x2_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x2);++ return CasADi::Matrix< CasADi::SX >::mul_no_alloc_nn(x0_, x1_, x2_);+}+++// ================== Static method: "mul_no_alloc_nt" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::mul_no_alloc_nt"+// cWrapperName: "CasADi__Matrix_CasADi__SX___mul_no_alloc_nt"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2)"+// args: "(x0_, x1_, x2_)"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__Matrix_CasADi__SX___mul_no_alloc_nt(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2)"+// call: "CasADi::Matrix< CasADi::SX >::mul_no_alloc_nt(x0_, x1_, x2_)"+extern "C"+ void CasADi__Matrix_CasADi__SX___mul_no_alloc_nt(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2);+void CasADi__Matrix_CasADi__SX___mul_no_alloc_nt(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);+ CasADi::Matrix< CasADi::SX > x1_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x1);+ CasADi::Matrix< CasADi::SX > x2_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x2);++ return CasADi::Matrix< CasADi::SX >::mul_no_alloc_nt(x0_, x1_, x2_);+}+++// ================== Static method: "mul_no_alloc_tn" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::mul_no_alloc_tn"+// cWrapperName: "CasADi__Matrix_CasADi__SX___mul_no_alloc_tn"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2)"+// args: "(x0_, x1_, x2_)"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__Matrix_CasADi__SX___mul_no_alloc_tn(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2)"+// call: "CasADi::Matrix< CasADi::SX >::mul_no_alloc_tn(x0_, x1_, x2_)"+extern "C"+ void CasADi__Matrix_CasADi__SX___mul_no_alloc_tn(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2);+void CasADi__Matrix_CasADi__SX___mul_no_alloc_tn(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);+ CasADi::Matrix< CasADi::SX > x1_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x1);+ CasADi::Matrix< CasADi::SX > x2_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x2);++ return CasADi::Matrix< CasADi::SX >::mul_no_alloc_tn(x0_, x1_, x2_);+}+++// ================== Static method: "mul_no_alloc_nn'" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::mul_no_alloc_nn'"+// cWrapperName: "CasADi__Matrix_CasADi__SX___mul_no_alloc_nn_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, std::vector<CasADi::SX* > * x1, std::vector<CasADi::SX* >* x2)"+// args: "(x0_, x1_, x2_)"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__Matrix_CasADi__SX___mul_no_alloc_nn_TIC(CasADi::Matrix< CasADi::SX >* x0, std::vector<CasADi::SX* > * x1, std::vector<CasADi::SX* >* x2)"+// call: "CasADi::Matrix< CasADi::SX >::mul_no_alloc_nn(x0_, x1_, x2_)"+extern "C"+ void CasADi__Matrix_CasADi__SX___mul_no_alloc_nn_TIC(CasADi::Matrix< CasADi::SX >* x0, std::vector<CasADi::SX* > * x1, std::vector<CasADi::SX* >* x2);+void CasADi__Matrix_CasADi__SX___mul_no_alloc_nn_TIC(CasADi::Matrix< CasADi::SX >* x0, std::vector<CasADi::SX* > * x1, std::vector<CasADi::SX* >* x2){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);+ std::vector<CasADi::SX > x1_ = Marshaling<std::vector<CasADi::SX >,std::vector<CasADi::SX* > *>::marshal(x1);+ std::vector<CasADi::SX > x2_ = Marshaling<std::vector<CasADi::SX >,std::vector<CasADi::SX* >*>::marshal(x2);++ return CasADi::Matrix< CasADi::SX >::mul_no_alloc_nn(x0_, x1_, x2_);+}+++// ================== Static method: "mul_no_alloc_tn'" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::mul_no_alloc_tn'"+// cWrapperName: "CasADi__Matrix_CasADi__SX___mul_no_alloc_tn_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, std::vector<CasADi::SX* > * x1, std::vector<CasADi::SX* >* x2)"+// args: "(x0_, x1_, x2_)"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__Matrix_CasADi__SX___mul_no_alloc_tn_TIC(CasADi::Matrix< CasADi::SX >* x0, std::vector<CasADi::SX* > * x1, std::vector<CasADi::SX* >* x2)"+// call: "CasADi::Matrix< CasADi::SX >::mul_no_alloc_tn(x0_, x1_, x2_)"+extern "C"+ void CasADi__Matrix_CasADi__SX___mul_no_alloc_tn_TIC(CasADi::Matrix< CasADi::SX >* x0, std::vector<CasADi::SX* > * x1, std::vector<CasADi::SX* >* x2);+void CasADi__Matrix_CasADi__SX___mul_no_alloc_tn_TIC(CasADi::Matrix< CasADi::SX >* x0, std::vector<CasADi::SX* > * x1, std::vector<CasADi::SX* >* x2){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);+ std::vector<CasADi::SX > x1_ = Marshaling<std::vector<CasADi::SX >,std::vector<CasADi::SX* > *>::marshal(x1);+ std::vector<CasADi::SX > x2_ = Marshaling<std::vector<CasADi::SX >,std::vector<CasADi::SX* >*>::marshal(x2);++ return CasADi::Matrix< CasADi::SX >::mul_no_alloc_tn(x0_, x1_, x2_);+}+++// ================== Static method: "quad_form" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::quad_form"+// cWrapperName: "CasADi__Matrix_CasADi__SX___quad_form"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, std::vector<CasADi::SX* > * x1)"+// args: "(x0_, x1_)"+// rettype: Val (NonVec (CasadiClass SX))+// cWrapperRetType: "CasADi::SX*"+// proto: "CasADi::SX* CasADi__Matrix_CasADi__SX___quad_form(CasADi::Matrix< CasADi::SX >* x0, std::vector<CasADi::SX* > * x1)"+// call: "CasADi::Matrix< CasADi::SX >::quad_form(x0_, x1_)"+extern "C"+ CasADi::SX* CasADi__Matrix_CasADi__SX___quad_form(CasADi::Matrix< CasADi::SX >* x0, std::vector<CasADi::SX* > * x1);+CasADi::SX* CasADi__Matrix_CasADi__SX___quad_form(CasADi::Matrix< CasADi::SX >* x0, std::vector<CasADi::SX* > * x1){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);+ std::vector<CasADi::SX > x1_ = Marshaling<std::vector<CasADi::SX >,std::vector<CasADi::SX* > *>::marshal(x1);++ return new CasADi::SX( CasADi::Matrix< CasADi::SX >::quad_form(x0_, x1_) );+}+++// ================== Normal method: "trans" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::trans"+// cWrapperName: "CasADi__Matrix_CasADi__SX___trans"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass SXMatrix))+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___trans(CasADi::Matrix< CasADi::SX >* obj)"+// call: "obj->trans()"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___trans(CasADi::Matrix< CasADi::SX >* obj);+CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___trans(CasADi::Matrix< CasADi::SX >* obj){++ return new CasADi::Matrix< CasADi::SX >( obj->trans() );+}+++// ================== Normal method: "sin" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::sin"+// cWrapperName: "CasADi__Matrix_CasADi__SX___sin"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass SXMatrix))+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___sin(CasADi::Matrix< CasADi::SX >* obj)"+// call: "obj->sin()"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___sin(CasADi::Matrix< CasADi::SX >* obj);+CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___sin(CasADi::Matrix< CasADi::SX >* obj){++ return new CasADi::Matrix< CasADi::SX >( obj->sin() );+}+++// ================== Normal method: "cos" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::cos"+// cWrapperName: "CasADi__Matrix_CasADi__SX___cos"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass SXMatrix))+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___cos(CasADi::Matrix< CasADi::SX >* obj)"+// call: "obj->cos()"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___cos(CasADi::Matrix< CasADi::SX >* obj);+CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___cos(CasADi::Matrix< CasADi::SX >* obj){++ return new CasADi::Matrix< CasADi::SX >( obj->cos() );+}+++// ================== Normal method: "tan" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::tan"+// cWrapperName: "CasADi__Matrix_CasADi__SX___tan"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass SXMatrix))+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___tan(CasADi::Matrix< CasADi::SX >* obj)"+// call: "obj->tan()"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___tan(CasADi::Matrix< CasADi::SX >* obj);+CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___tan(CasADi::Matrix< CasADi::SX >* obj){++ return new CasADi::Matrix< CasADi::SX >( obj->tan() );+}+++// ================== Normal method: "arcsin" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::arcsin"+// cWrapperName: "CasADi__Matrix_CasADi__SX___arcsin"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass SXMatrix))+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___arcsin(CasADi::Matrix< CasADi::SX >* obj)"+// call: "obj->arcsin()"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___arcsin(CasADi::Matrix< CasADi::SX >* obj);+CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___arcsin(CasADi::Matrix< CasADi::SX >* obj){++ return new CasADi::Matrix< CasADi::SX >( obj->arcsin() );+}+++// ================== Normal method: "arccos" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::arccos"+// cWrapperName: "CasADi__Matrix_CasADi__SX___arccos"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass SXMatrix))+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___arccos(CasADi::Matrix< CasADi::SX >* obj)"+// call: "obj->arccos()"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___arccos(CasADi::Matrix< CasADi::SX >* obj);+CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___arccos(CasADi::Matrix< CasADi::SX >* obj){++ return new CasADi::Matrix< CasADi::SX >( obj->arccos() );+}+++// ================== Normal method: "arctan" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::arctan"+// cWrapperName: "CasADi__Matrix_CasADi__SX___arctan"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass SXMatrix))+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___arctan(CasADi::Matrix< CasADi::SX >* obj)"+// call: "obj->arctan()"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___arctan(CasADi::Matrix< CasADi::SX >* obj);+CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___arctan(CasADi::Matrix< CasADi::SX >* obj){++ return new CasADi::Matrix< CasADi::SX >( obj->arctan() );+}+++// ================== Normal method: "exp" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::exp"+// cWrapperName: "CasADi__Matrix_CasADi__SX___exp"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass SXMatrix))+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___exp(CasADi::Matrix< CasADi::SX >* obj)"+// call: "obj->exp()"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___exp(CasADi::Matrix< CasADi::SX >* obj);+CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___exp(CasADi::Matrix< CasADi::SX >* obj){++ return new CasADi::Matrix< CasADi::SX >( obj->exp() );+}+++// ================== Normal method: "log" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::log"+// cWrapperName: "CasADi__Matrix_CasADi__SX___log"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass SXMatrix))+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___log(CasADi::Matrix< CasADi::SX >* obj)"+// call: "obj->log()"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___log(CasADi::Matrix< CasADi::SX >* obj);+CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___log(CasADi::Matrix< CasADi::SX >* obj){++ return new CasADi::Matrix< CasADi::SX >( obj->log() );+}+++// ================== Normal method: "sqrt" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::sqrt"+// cWrapperName: "CasADi__Matrix_CasADi__SX___sqrt"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass SXMatrix))+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___sqrt(CasADi::Matrix< CasADi::SX >* obj)"+// call: "obj->sqrt()"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___sqrt(CasADi::Matrix< CasADi::SX >* obj);+CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___sqrt(CasADi::Matrix< CasADi::SX >* obj){++ return new CasADi::Matrix< CasADi::SX >( obj->sqrt() );+}+++// ================== Normal method: "floor" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::floor"+// cWrapperName: "CasADi__Matrix_CasADi__SX___floor"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass SXMatrix))+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___floor(CasADi::Matrix< CasADi::SX >* obj)"+// call: "obj->floor()"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___floor(CasADi::Matrix< CasADi::SX >* obj);+CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___floor(CasADi::Matrix< CasADi::SX >* obj){++ return new CasADi::Matrix< CasADi::SX >( obj->floor() );+}+++// ================== Normal method: "ceil" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::ceil"+// cWrapperName: "CasADi__Matrix_CasADi__SX___ceil"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass SXMatrix))+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___ceil(CasADi::Matrix< CasADi::SX >* obj)"+// call: "obj->ceil()"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___ceil(CasADi::Matrix< CasADi::SX >* obj);+CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___ceil(CasADi::Matrix< CasADi::SX >* obj){++ return new CasADi::Matrix< CasADi::SX >( obj->ceil() );+}+++// ================== Normal method: "fabs" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::fabs"+// cWrapperName: "CasADi__Matrix_CasADi__SX___fabs"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass SXMatrix))+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___fabs(CasADi::Matrix< CasADi::SX >* obj)"+// call: "obj->fabs()"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___fabs(CasADi::Matrix< CasADi::SX >* obj);+CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___fabs(CasADi::Matrix< CasADi::SX >* obj){++ return new CasADi::Matrix< CasADi::SX >( obj->fabs() );+}+++// ================== Normal method: "sign" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::sign"+// cWrapperName: "CasADi__Matrix_CasADi__SX___sign"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass SXMatrix))+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___sign(CasADi::Matrix< CasADi::SX >* obj)"+// call: "obj->sign()"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___sign(CasADi::Matrix< CasADi::SX >* obj);+CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___sign(CasADi::Matrix< CasADi::SX >* obj){++ return new CasADi::Matrix< CasADi::SX >( obj->sign() );+}+++// ================== Normal method: "erfinv" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::erfinv"+// cWrapperName: "CasADi__Matrix_CasADi__SX___erfinv"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass SXMatrix))+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___erfinv(CasADi::Matrix< CasADi::SX >* obj)"+// call: "obj->erfinv()"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___erfinv(CasADi::Matrix< CasADi::SX >* obj);+CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___erfinv(CasADi::Matrix< CasADi::SX >* obj){++ return new CasADi::Matrix< CasADi::SX >( obj->erfinv() );+}+++// ================== Normal method: "fmin" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::fmin"+// cWrapperName: "CasADi__Matrix_CasADi__SX___fmin"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass SXMatrix))+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___fmin(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0)"+// call: "obj->fmin(x0_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___fmin(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0);+CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___fmin(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);++ return new CasADi::Matrix< CasADi::SX >( obj->fmin(x0_) );+}+++// ================== Normal method: "fmax" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::fmax"+// cWrapperName: "CasADi__Matrix_CasADi__SX___fmax"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass SXMatrix))+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___fmax(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0)"+// call: "obj->fmax(x0_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___fmax(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0);+CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___fmax(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);++ return new CasADi::Matrix< CasADi::SX >( obj->fmax(x0_) );+}+++// ================== Normal method: "erf" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::erf"+// cWrapperName: "CasADi__Matrix_CasADi__SX___erf"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass SXMatrix))+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___erf(CasADi::Matrix< CasADi::SX >* obj)"+// call: "obj->erf()"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___erf(CasADi::Matrix< CasADi::SX >* obj);+CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___erf(CasADi::Matrix< CasADi::SX >* obj){++ return new CasADi::Matrix< CasADi::SX >( obj->erf() );+}+++// ================== Normal method: "sinh" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::sinh"+// cWrapperName: "CasADi__Matrix_CasADi__SX___sinh"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass SXMatrix))+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___sinh(CasADi::Matrix< CasADi::SX >* obj)"+// call: "obj->sinh()"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___sinh(CasADi::Matrix< CasADi::SX >* obj);+CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___sinh(CasADi::Matrix< CasADi::SX >* obj){++ return new CasADi::Matrix< CasADi::SX >( obj->sinh() );+}+++// ================== Normal method: "cosh" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::cosh"+// cWrapperName: "CasADi__Matrix_CasADi__SX___cosh"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass SXMatrix))+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___cosh(CasADi::Matrix< CasADi::SX >* obj)"+// call: "obj->cosh()"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___cosh(CasADi::Matrix< CasADi::SX >* obj);+CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___cosh(CasADi::Matrix< CasADi::SX >* obj){++ return new CasADi::Matrix< CasADi::SX >( obj->cosh() );+}+++// ================== Normal method: "tanh" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::tanh"+// cWrapperName: "CasADi__Matrix_CasADi__SX___tanh"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass SXMatrix))+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___tanh(CasADi::Matrix< CasADi::SX >* obj)"+// call: "obj->tanh()"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___tanh(CasADi::Matrix< CasADi::SX >* obj);+CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___tanh(CasADi::Matrix< CasADi::SX >* obj){++ return new CasADi::Matrix< CasADi::SX >( obj->tanh() );+}+++// ================== Normal method: "arcsinh" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::arcsinh"+// cWrapperName: "CasADi__Matrix_CasADi__SX___arcsinh"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass SXMatrix))+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___arcsinh(CasADi::Matrix< CasADi::SX >* obj)"+// call: "obj->arcsinh()"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___arcsinh(CasADi::Matrix< CasADi::SX >* obj);+CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___arcsinh(CasADi::Matrix< CasADi::SX >* obj){++ return new CasADi::Matrix< CasADi::SX >( obj->arcsinh() );+}+++// ================== Normal method: "arccosh" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::arccosh"+// cWrapperName: "CasADi__Matrix_CasADi__SX___arccosh"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass SXMatrix))+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___arccosh(CasADi::Matrix< CasADi::SX >* obj)"+// call: "obj->arccosh()"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___arccosh(CasADi::Matrix< CasADi::SX >* obj);+CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___arccosh(CasADi::Matrix< CasADi::SX >* obj){++ return new CasADi::Matrix< CasADi::SX >( obj->arccosh() );+}+++// ================== Normal method: "arctanh" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::arctanh"+// cWrapperName: "CasADi__Matrix_CasADi__SX___arctanh"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass SXMatrix))+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___arctanh(CasADi::Matrix< CasADi::SX >* obj)"+// call: "obj->arctanh()"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___arctanh(CasADi::Matrix< CasADi::SX >* obj);+CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___arctanh(CasADi::Matrix< CasADi::SX >* obj){++ return new CasADi::Matrix< CasADi::SX >( obj->arctanh() );+}+++// ================== Normal method: "arctan2" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::arctan2"+// cWrapperName: "CasADi__Matrix_CasADi__SX___arctan2"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass SXMatrix))+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___arctan2(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0)"+// call: "obj->arctan2(x0_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___arctan2(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0);+CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___arctan2(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);++ return new CasADi::Matrix< CasADi::SX >( obj->arctan2(x0_) );+}+++// ================== Normal method: "log10" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::log10"+// cWrapperName: "CasADi__Matrix_CasADi__SX___log10"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass SXMatrix))+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___log10(CasADi::Matrix< CasADi::SX >* obj)"+// call: "obj->log10()"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___log10(CasADi::Matrix< CasADi::SX >* obj);+CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___log10(CasADi::Matrix< CasADi::SX >* obj){++ return new CasADi::Matrix< CasADi::SX >( obj->log10() );+}+++// ================== Normal method: "printme" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::printme"+// cWrapperName: "CasADi__Matrix_CasADi__SX___printme"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass SXMatrix))+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___printme(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0)"+// call: "obj->printme(x0_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___printme(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0);+CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___printme(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);++ return new CasADi::Matrix< CasADi::SX >( obj->printme(x0_) );+}+++// ================== Normal method: "logic_not" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::logic_not"+// cWrapperName: "CasADi__Matrix_CasADi__SX___logic_not"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass SXMatrix))+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___logic_not(CasADi::Matrix< CasADi::SX >* obj)"+// call: "obj->logic_not()"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___logic_not(CasADi::Matrix< CasADi::SX >* obj);+CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___logic_not(CasADi::Matrix< CasADi::SX >* obj){++ return new CasADi::Matrix< CasADi::SX >( obj->logic_not() );+}+++// ================== Normal method: "logic_and" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::logic_and"+// cWrapperName: "CasADi__Matrix_CasADi__SX___logic_and"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass SXMatrix))+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___logic_and(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0)"+// call: "obj->logic_and(x0_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___logic_and(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0);+CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___logic_and(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);++ return new CasADi::Matrix< CasADi::SX >( obj->logic_and(x0_) );+}+++// ================== Normal method: "logic_or" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::logic_or"+// cWrapperName: "CasADi__Matrix_CasADi__SX___logic_or"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass SXMatrix))+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___logic_or(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0)"+// call: "obj->logic_or(x0_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___logic_or(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0);+CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___logic_or(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);++ return new CasADi::Matrix< CasADi::SX >( obj->logic_or(x0_) );+}+++// ================== Normal method: "if_else_zero" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::if_else_zero"+// cWrapperName: "CasADi__Matrix_CasADi__SX___if_else_zero"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass SXMatrix))+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___if_else_zero(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0)"+// call: "obj->if_else_zero(x0_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___if_else_zero(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0);+CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___if_else_zero(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);++ return new CasADi::Matrix< CasADi::SX >( obj->if_else_zero(x0_) );+}+++// ================== Static method: "className" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::className"+// cWrapperName: "CasADi__Matrix_CasADi__SX___className"+// protoArgs: "()"+// args: "()"+// rettype: Val (NonVec StdString)+// cWrapperRetType: "std::string*"+// proto: "std::string* CasADi__Matrix_CasADi__SX___className()"+// call: "CasADi::Matrix< CasADi::SX >::className()"+extern "C"+ std::string* CasADi__Matrix_CasADi__SX___className();+std::string* CasADi__Matrix_CasADi__SX___className(){++ return new std::string( CasADi::Matrix< CasADi::SX >::className() );+}+++// ================== Normal method: "printScalar'" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::printScalar'"+// cWrapperName: "CasADi__Matrix_CasADi__SX___printScalar_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj)"+// args: "()"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__Matrix_CasADi__SX___printScalar_TIC(CasADi::Matrix< CasADi::SX >* obj)"+// call: "obj->printScalar()"+extern "C"+ void CasADi__Matrix_CasADi__SX___printScalar_TIC(CasADi::Matrix< CasADi::SX >* obj);+void CasADi__Matrix_CasADi__SX___printScalar_TIC(CasADi::Matrix< CasADi::SX >* obj){++ return obj->printScalar();+}+++// ================== Normal method: "printVector'" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::printVector'"+// cWrapperName: "CasADi__Matrix_CasADi__SX___printVector_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj)"+// args: "()"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__Matrix_CasADi__SX___printVector_TIC(CasADi::Matrix< CasADi::SX >* obj)"+// call: "obj->printVector()"+extern "C"+ void CasADi__Matrix_CasADi__SX___printVector_TIC(CasADi::Matrix< CasADi::SX >* obj);+void CasADi__Matrix_CasADi__SX___printVector_TIC(CasADi::Matrix< CasADi::SX >* obj){++ return obj->printVector();+}+++// ================== Normal method: "printMatrix'" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::printMatrix'"+// cWrapperName: "CasADi__Matrix_CasADi__SX___printMatrix_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj)"+// args: "()"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__Matrix_CasADi__SX___printMatrix_TIC(CasADi::Matrix< CasADi::SX >* obj)"+// call: "obj->printMatrix()"+extern "C"+ void CasADi__Matrix_CasADi__SX___printMatrix_TIC(CasADi::Matrix< CasADi::SX >* obj);+void CasADi__Matrix_CasADi__SX___printMatrix_TIC(CasADi::Matrix< CasADi::SX >* obj){++ return obj->printMatrix();+}+++// ================== Normal method: "printSparse'" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::printSparse'"+// cWrapperName: "CasADi__Matrix_CasADi__SX___printSparse_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj)"+// args: "()"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__Matrix_CasADi__SX___printSparse_TIC(CasADi::Matrix< CasADi::SX >* obj)"+// call: "obj->printSparse()"+extern "C"+ void CasADi__Matrix_CasADi__SX___printSparse_TIC(CasADi::Matrix< CasADi::SX >* obj);+void CasADi__Matrix_CasADi__SX___printSparse_TIC(CasADi::Matrix< CasADi::SX >* obj){++ return obj->printSparse();+}+++// ================== Normal method: "printDense'" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::printDense'"+// cWrapperName: "CasADi__Matrix_CasADi__SX___printDense_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj)"+// args: "()"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__Matrix_CasADi__SX___printDense_TIC(CasADi::Matrix< CasADi::SX >* obj)"+// call: "obj->printDense()"+extern "C"+ void CasADi__Matrix_CasADi__SX___printDense_TIC(CasADi::Matrix< CasADi::SX >* obj);+void CasADi__Matrix_CasADi__SX___printDense_TIC(CasADi::Matrix< CasADi::SX >* obj){++ return obj->printDense();+}+++// ================== Normal method: "col" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::col"+// cWrapperName: "CasADi__Matrix_CasADi__SX___col"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj, int x0)"+// args: "(x0_)"+// rettype: Val (NonVec CInt)+// cWrapperRetType: "int"+// proto: "int CasADi__Matrix_CasADi__SX___col(CasADi::Matrix< CasADi::SX >* obj, int x0)"+// call: "obj->col(x0_)"+extern "C"+ int CasADi__Matrix_CasADi__SX___col(CasADi::Matrix< CasADi::SX >* obj, int x0);+int CasADi__Matrix_CasADi__SX___col(CasADi::Matrix< CasADi::SX >* obj, int x0){+ int x0_ = Marshaling<int,int>::marshal(x0);++ return obj->col(x0_);+}+++// ================== Normal method: "rowind" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::rowind"+// cWrapperName: "CasADi__Matrix_CasADi__SX___rowind"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj, int x0)"+// args: "(x0_)"+// rettype: Val (NonVec CInt)+// cWrapperRetType: "int"+// proto: "int CasADi__Matrix_CasADi__SX___rowind(CasADi::Matrix< CasADi::SX >* obj, int x0)"+// call: "obj->rowind(x0_)"+extern "C"+ int CasADi__Matrix_CasADi__SX___rowind(CasADi::Matrix< CasADi::SX >* obj, int x0);+int CasADi__Matrix_CasADi__SX___rowind(CasADi::Matrix< CasADi::SX >* obj, int x0){+ int x0_ = Marshaling<int,int>::marshal(x0);++ return obj->rowind(x0_);+}+++// ================== Normal method: "clear" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::clear"+// cWrapperName: "CasADi__Matrix_CasADi__SX___clear"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj)"+// args: "()"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__Matrix_CasADi__SX___clear(CasADi::Matrix< CasADi::SX >* obj)"+// call: "obj->clear()"+extern "C"+ void CasADi__Matrix_CasADi__SX___clear(CasADi::Matrix< CasADi::SX >* obj);+void CasADi__Matrix_CasADi__SX___clear(CasADi::Matrix< CasADi::SX >* obj){++ return obj->clear();+}+++// ================== Normal method: "resize" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::resize"+// cWrapperName: "CasADi__Matrix_CasADi__SX___resize"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj, int x0, int x1)"+// args: "(x0_, x1_)"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__Matrix_CasADi__SX___resize(CasADi::Matrix< CasADi::SX >* obj, int x0, int x1)"+// call: "obj->resize(x0_, x1_)"+extern "C"+ void CasADi__Matrix_CasADi__SX___resize(CasADi::Matrix< CasADi::SX >* obj, int x0, int x1);+void CasADi__Matrix_CasADi__SX___resize(CasADi::Matrix< CasADi::SX >* obj, int x0, int x1){+ int x0_ = Marshaling<int,int>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);++ return obj->resize(x0_, x1_);+}+++// ================== Normal method: "reserve" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::reserve"+// cWrapperName: "CasADi__Matrix_CasADi__SX___reserve"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj, int x0)"+// args: "(x0_)"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__Matrix_CasADi__SX___reserve(CasADi::Matrix< CasADi::SX >* obj, int x0)"+// call: "obj->reserve(x0_)"+extern "C"+ void CasADi__Matrix_CasADi__SX___reserve(CasADi::Matrix< CasADi::SX >* obj, int x0);+void CasADi__Matrix_CasADi__SX___reserve(CasADi::Matrix< CasADi::SX >* obj, int x0){+ int x0_ = Marshaling<int,int>::marshal(x0);++ return obj->reserve(x0_);+}+++// ================== Normal method: "reserve'" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::reserve'"+// cWrapperName: "CasADi__Matrix_CasADi__SX___reserve_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj, int x0, int x1)"+// args: "(x0_, x1_)"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__Matrix_CasADi__SX___reserve_TIC(CasADi::Matrix< CasADi::SX >* obj, int x0, int x1)"+// call: "obj->reserve(x0_, x1_)"+extern "C"+ void CasADi__Matrix_CasADi__SX___reserve_TIC(CasADi::Matrix< CasADi::SX >* obj, int x0, int x1);+void CasADi__Matrix_CasADi__SX___reserve_TIC(CasADi::Matrix< CasADi::SX >* obj, int x0, int x1){+ int x0_ = Marshaling<int,int>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);++ return obj->reserve(x0_, x1_);+}+++// ================== Normal method: "erase" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::erase"+// cWrapperName: "CasADi__Matrix_CasADi__SX___erase"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj, std::vector<int > * x0, std::vector<int > * x1)"+// args: "(x0_, x1_)"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__Matrix_CasADi__SX___erase(CasADi::Matrix< CasADi::SX >* obj, std::vector<int > * x0, std::vector<int > * x1)"+// call: "obj->erase(x0_, x1_)"+extern "C"+ void CasADi__Matrix_CasADi__SX___erase(CasADi::Matrix< CasADi::SX >* obj, std::vector<int > * x0, std::vector<int > * x1);+void CasADi__Matrix_CasADi__SX___erase(CasADi::Matrix< CasADi::SX >* obj, std::vector<int > * x0, std::vector<int > * x1){+ std::vector<int > x0_ = Marshaling<std::vector<int >,std::vector<int > *>::marshal(x0);+ std::vector<int > x1_ = Marshaling<std::vector<int >,std::vector<int > *>::marshal(x1);++ return obj->erase(x0_, x1_);+}+++// ================== Normal method: "remove" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::remove"+// cWrapperName: "CasADi__Matrix_CasADi__SX___remove"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj, std::vector<int > * x0, std::vector<int > * x1)"+// args: "(x0_, x1_)"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__Matrix_CasADi__SX___remove(CasADi::Matrix< CasADi::SX >* obj, std::vector<int > * x0, std::vector<int > * x1)"+// call: "obj->remove(x0_, x1_)"+extern "C"+ void CasADi__Matrix_CasADi__SX___remove(CasADi::Matrix< CasADi::SX >* obj, std::vector<int > * x0, std::vector<int > * x1);+void CasADi__Matrix_CasADi__SX___remove(CasADi::Matrix< CasADi::SX >* obj, std::vector<int > * x0, std::vector<int > * x1){+ std::vector<int > x0_ = Marshaling<std::vector<int >,std::vector<int > *>::marshal(x0);+ std::vector<int > x1_ = Marshaling<std::vector<int >,std::vector<int > *>::marshal(x1);++ return obj->remove(x0_, x1_);+}+++// ================== Normal method: "enlarge" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::enlarge"+// cWrapperName: "CasADi__Matrix_CasADi__SX___enlarge"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj, int x0, int x1, std::vector<int > * x2, std::vector<int > * x3)"+// args: "(x0_, x1_, x2_, x3_)"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__Matrix_CasADi__SX___enlarge(CasADi::Matrix< CasADi::SX >* obj, int x0, int x1, std::vector<int > * x2, std::vector<int > * x3)"+// call: "obj->enlarge(x0_, x1_, x2_, x3_)"+extern "C"+ void CasADi__Matrix_CasADi__SX___enlarge(CasADi::Matrix< CasADi::SX >* obj, int x0, int x1, std::vector<int > * x2, std::vector<int > * x3);+void CasADi__Matrix_CasADi__SX___enlarge(CasADi::Matrix< CasADi::SX >* obj, int x0, int x1, std::vector<int > * x2, std::vector<int > * x3){+ int x0_ = Marshaling<int,int>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);+ std::vector<int > x2_ = Marshaling<std::vector<int >,std::vector<int > *>::marshal(x2);+ std::vector<int > x3_ = Marshaling<std::vector<int >,std::vector<int > *>::marshal(x3);++ return obj->enlarge(x0_, x1_, x2_, x3_);+}+++// ================== Normal method: "data" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::data"+// cWrapperName: "CasADi__Matrix_CasADi__SX___data"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj)"+// args: "()"+// rettype: Val (Vec (NonVec (CasadiClass SX)))+// cWrapperRetType: "std::vector<CasADi::SX >*"+// proto: "std::vector<CasADi::SX >* CasADi__Matrix_CasADi__SX___data(CasADi::Matrix< CasADi::SX >* obj)"+// call: "obj->data()"+extern "C"+ std::vector<CasADi::SX >* CasADi__Matrix_CasADi__SX___data(CasADi::Matrix< CasADi::SX >* obj);+std::vector<CasADi::SX >* CasADi__Matrix_CasADi__SX___data(CasADi::Matrix< CasADi::SX >* obj){++ return new std::vector<CasADi::SX >( obj->data() );+}+++// ================== Normal method: "sparsityRef" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::sparsityRef"+// cWrapperName: "CasADi__Matrix_CasADi__SX___sparsityRef"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass CRSSparsity))+// cWrapperRetType: "CasADi::CRSSparsity*"+// proto: "CasADi::CRSSparsity* CasADi__Matrix_CasADi__SX___sparsityRef(CasADi::Matrix< CasADi::SX >* obj)"+// call: "obj->sparsityRef()"+extern "C"+ CasADi::CRSSparsity* CasADi__Matrix_CasADi__SX___sparsityRef(CasADi::Matrix< CasADi::SX >* obj);+CasADi::CRSSparsity* CasADi__Matrix_CasADi__SX___sparsityRef(CasADi::Matrix< CasADi::SX >* obj){++ return new CasADi::CRSSparsity( obj->sparsityRef() );+}+++// ================== Normal method: "set" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::set"+// cWrapperName: "CasADi__Matrix_CasADi__SX___set"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj, CasADi::SX* x0, CasADi::Sparsity x1)"+// args: "(x0_, x1_)"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__Matrix_CasADi__SX___set(CasADi::Matrix< CasADi::SX >* obj, CasADi::SX* x0, CasADi::Sparsity x1)"+// call: "obj->set(x0_, x1_)"+extern "C"+ void CasADi__Matrix_CasADi__SX___set(CasADi::Matrix< CasADi::SX >* obj, CasADi::SX* x0, CasADi::Sparsity x1);+void CasADi__Matrix_CasADi__SX___set(CasADi::Matrix< CasADi::SX >* obj, CasADi::SX* x0, CasADi::Sparsity x1){+ CasADi::SX x0_ = Marshaling<CasADi::SX,CasADi::SX*>::marshal(x0);+ CasADi::Sparsity x1_ = Marshaling<CasADi::Sparsity,CasADi::Sparsity>::marshal(x1);++ return obj->set(x0_, x1_);+}+++// ================== Normal method: "set'" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::set'"+// cWrapperName: "CasADi__Matrix_CasADi__SX___set_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj, CasADi::SX* x0)"+// args: "(x0_)"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__Matrix_CasADi__SX___set_TIC(CasADi::Matrix< CasADi::SX >* obj, CasADi::SX* x0)"+// call: "obj->set(x0_)"+extern "C"+ void CasADi__Matrix_CasADi__SX___set_TIC(CasADi::Matrix< CasADi::SX >* obj, CasADi::SX* x0);+void CasADi__Matrix_CasADi__SX___set_TIC(CasADi::Matrix< CasADi::SX >* obj, CasADi::SX* x0){+ CasADi::SX x0_ = Marshaling<CasADi::SX,CasADi::SX*>::marshal(x0);++ return obj->set(x0_);+}+++// ================== Normal method: "get" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::get"+// cWrapperName: "CasADi__Matrix_CasADi__SX___get"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj, CasADi::SX* x0, CasADi::Sparsity x1)"+// args: "(x0_, x1_)"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__Matrix_CasADi__SX___get(CasADi::Matrix< CasADi::SX >* obj, CasADi::SX* x0, CasADi::Sparsity x1)"+// call: "obj->get(x0_, x1_)"+extern "C"+ void CasADi__Matrix_CasADi__SX___get(CasADi::Matrix< CasADi::SX >* obj, CasADi::SX* x0, CasADi::Sparsity x1);+void CasADi__Matrix_CasADi__SX___get(CasADi::Matrix< CasADi::SX >* obj, CasADi::SX* x0, CasADi::Sparsity x1){+ CasADi::SX x0_ = Marshaling<CasADi::SX,CasADi::SX*>::marshal(x0);+ CasADi::Sparsity x1_ = Marshaling<CasADi::Sparsity,CasADi::Sparsity>::marshal(x1);++ return obj->get(x0_, x1_);+}+++// ================== Normal method: "get'" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::get'"+// cWrapperName: "CasADi__Matrix_CasADi__SX___get_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj, CasADi::SX* x0)"+// args: "(x0_)"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__Matrix_CasADi__SX___get_TIC(CasADi::Matrix< CasADi::SX >* obj, CasADi::SX* x0)"+// call: "obj->get(x0_)"+extern "C"+ void CasADi__Matrix_CasADi__SX___get_TIC(CasADi::Matrix< CasADi::SX >* obj, CasADi::SX* x0);+void CasADi__Matrix_CasADi__SX___get_TIC(CasADi::Matrix< CasADi::SX >* obj, CasADi::SX* x0){+ CasADi::SX x0_ = Marshaling<CasADi::SX,CasADi::SX*>::marshal(x0);++ return obj->get(x0_);+}+++// ================== Normal method: "set''" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::set''"+// cWrapperName: "CasADi__Matrix_CasADi__SX___set_TIC_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj, std::vector<CasADi::SX* > * x0, CasADi::Sparsity x1)"+// args: "(x0_, x1_)"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__Matrix_CasADi__SX___set_TIC_TIC(CasADi::Matrix< CasADi::SX >* obj, std::vector<CasADi::SX* > * x0, CasADi::Sparsity x1)"+// call: "obj->set(x0_, x1_)"+extern "C"+ void CasADi__Matrix_CasADi__SX___set_TIC_TIC(CasADi::Matrix< CasADi::SX >* obj, std::vector<CasADi::SX* > * x0, CasADi::Sparsity x1);+void CasADi__Matrix_CasADi__SX___set_TIC_TIC(CasADi::Matrix< CasADi::SX >* obj, std::vector<CasADi::SX* > * x0, CasADi::Sparsity x1){+ std::vector<CasADi::SX > x0_ = Marshaling<std::vector<CasADi::SX >,std::vector<CasADi::SX* > *>::marshal(x0);+ CasADi::Sparsity x1_ = Marshaling<CasADi::Sparsity,CasADi::Sparsity>::marshal(x1);++ return obj->set(x0_, x1_);+}+++// ================== Normal method: "set'''" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::set'''"+// cWrapperName: "CasADi__Matrix_CasADi__SX___set_TIC_TIC_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj, std::vector<CasADi::SX* > * x0)"+// args: "(x0_)"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__Matrix_CasADi__SX___set_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* obj, std::vector<CasADi::SX* > * x0)"+// call: "obj->set(x0_)"+extern "C"+ void CasADi__Matrix_CasADi__SX___set_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* obj, std::vector<CasADi::SX* > * x0);+void CasADi__Matrix_CasADi__SX___set_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* obj, std::vector<CasADi::SX* > * x0){+ std::vector<CasADi::SX > x0_ = Marshaling<std::vector<CasADi::SX >,std::vector<CasADi::SX* > *>::marshal(x0);++ return obj->set(x0_);+}+++// ================== Normal method: "get''" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::get''"+// cWrapperName: "CasADi__Matrix_CasADi__SX___get_TIC_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj, std::vector<CasADi::SX* >* x0, CasADi::Sparsity x1)"+// args: "(x0_, x1_)"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__Matrix_CasADi__SX___get_TIC_TIC(CasADi::Matrix< CasADi::SX >* obj, std::vector<CasADi::SX* >* x0, CasADi::Sparsity x1)"+// call: "obj->get(x0_, x1_)"+extern "C"+ void CasADi__Matrix_CasADi__SX___get_TIC_TIC(CasADi::Matrix< CasADi::SX >* obj, std::vector<CasADi::SX* >* x0, CasADi::Sparsity x1);+void CasADi__Matrix_CasADi__SX___get_TIC_TIC(CasADi::Matrix< CasADi::SX >* obj, std::vector<CasADi::SX* >* x0, CasADi::Sparsity x1){+ std::vector<CasADi::SX > x0_ = Marshaling<std::vector<CasADi::SX >,std::vector<CasADi::SX* >*>::marshal(x0);+ CasADi::Sparsity x1_ = Marshaling<CasADi::Sparsity,CasADi::Sparsity>::marshal(x1);++ return obj->get(x0_, x1_);+}+++// ================== Normal method: "get'''" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::get'''"+// cWrapperName: "CasADi__Matrix_CasADi__SX___get_TIC_TIC_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj, std::vector<CasADi::SX* >* x0)"+// args: "(x0_)"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__Matrix_CasADi__SX___get_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* obj, std::vector<CasADi::SX* >* x0)"+// call: "obj->get(x0_)"+extern "C"+ void CasADi__Matrix_CasADi__SX___get_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* obj, std::vector<CasADi::SX* >* x0);+void CasADi__Matrix_CasADi__SX___get_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* obj, std::vector<CasADi::SX* >* x0){+ std::vector<CasADi::SX > x0_ = Marshaling<std::vector<CasADi::SX >,std::vector<CasADi::SX* >*>::marshal(x0);++ return obj->get(x0_);+}+++// ================== Normal method: "set''''" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::set''''"+// cWrapperName: "CasADi__Matrix_CasADi__SX___set_TIC_TIC_TIC_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0, CasADi::Sparsity x1)"+// args: "(x0_, x1_)"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__Matrix_CasADi__SX___set_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0, CasADi::Sparsity x1)"+// call: "obj->set(x0_, x1_)"+extern "C"+ void CasADi__Matrix_CasADi__SX___set_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0, CasADi::Sparsity x1);+void CasADi__Matrix_CasADi__SX___set_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0, CasADi::Sparsity x1){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);+ CasADi::Sparsity x1_ = Marshaling<CasADi::Sparsity,CasADi::Sparsity>::marshal(x1);++ return obj->set(x0_, x1_);+}+++// ================== Normal method: "set'''''" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::set'''''"+// cWrapperName: "CasADi__Matrix_CasADi__SX___set_TIC_TIC_TIC_TIC_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0)"+// args: "(x0_)"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__Matrix_CasADi__SX___set_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0)"+// call: "obj->set(x0_)"+extern "C"+ void CasADi__Matrix_CasADi__SX___set_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0);+void CasADi__Matrix_CasADi__SX___set_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);++ return obj->set(x0_);+}+++// ================== Normal method: "get''''" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::get''''"+// cWrapperName: "CasADi__Matrix_CasADi__SX___get_TIC_TIC_TIC_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0, CasADi::Sparsity x1)"+// args: "(x0_, x1_)"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__Matrix_CasADi__SX___get_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0, CasADi::Sparsity x1)"+// call: "obj->get(x0_, x1_)"+extern "C"+ void CasADi__Matrix_CasADi__SX___get_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0, CasADi::Sparsity x1);+void CasADi__Matrix_CasADi__SX___get_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0, CasADi::Sparsity x1){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);+ CasADi::Sparsity x1_ = Marshaling<CasADi::Sparsity,CasADi::Sparsity>::marshal(x1);++ return obj->get(x0_, x1_);+}+++// ================== Normal method: "get'''''" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::get'''''"+// cWrapperName: "CasADi__Matrix_CasADi__SX___get_TIC_TIC_TIC_TIC_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0)"+// args: "(x0_)"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__Matrix_CasADi__SX___get_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0)"+// call: "obj->get(x0_)"+extern "C"+ void CasADi__Matrix_CasADi__SX___get_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0);+void CasADi__Matrix_CasADi__SX___get_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* obj, CasADi::Matrix< CasADi::SX >* x0){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);++ return obj->get(x0_);+}+++// ================== Static method: "sparse" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::sparse"+// cWrapperName: "CasADi__Matrix_CasADi__SX___sparse"+// protoArgs: "(int x0, int x1)"+// args: "(x0_, x1_)"+// rettype: Val (NonVec (CasadiClass SXMatrix))+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___sparse(int x0, int x1)"+// call: "CasADi::Matrix< CasADi::SX >::sparse(x0_, x1_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___sparse(int x0, int x1);+CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___sparse(int x0, int x1){+ int x0_ = Marshaling<int,int>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);++ return new CasADi::Matrix< CasADi::SX >( CasADi::Matrix< CasADi::SX >::sparse(x0_, x1_) );+}+++// ================== Static method: "sparse'" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::sparse'"+// cWrapperName: "CasADi__Matrix_CasADi__SX___sparse_TIC"+// protoArgs: "(int x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass SXMatrix))+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___sparse_TIC(int x0)"+// call: "CasADi::Matrix< CasADi::SX >::sparse(x0_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___sparse_TIC(int x0);+CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___sparse_TIC(int x0){+ int x0_ = Marshaling<int,int>::marshal(x0);++ return new CasADi::Matrix< CasADi::SX >( CasADi::Matrix< CasADi::SX >::sparse(x0_) );+}+++// ================== Static method: "sparse''" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::sparse''"+// cWrapperName: "CasADi__Matrix_CasADi__SX___sparse_TIC_TIC"+// protoArgs: "(std::vector<int > * x0, std::vector<int > * x1, std::vector<CasADi::SX* > * x2)"+// args: "(x0_, x1_, x2_)"+// rettype: Val (NonVec (CasadiClass SXMatrix))+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___sparse_TIC_TIC(std::vector<int > * x0, std::vector<int > * x1, std::vector<CasADi::SX* > * x2)"+// call: "CasADi::Matrix< CasADi::SX >::sparse(x0_, x1_, x2_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___sparse_TIC_TIC(std::vector<int > * x0, std::vector<int > * x1, std::vector<CasADi::SX* > * x2);+CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___sparse_TIC_TIC(std::vector<int > * x0, std::vector<int > * x1, std::vector<CasADi::SX* > * x2){+ std::vector<int > x0_ = Marshaling<std::vector<int >,std::vector<int > *>::marshal(x0);+ std::vector<int > x1_ = Marshaling<std::vector<int >,std::vector<int > *>::marshal(x1);+ std::vector<CasADi::SX > x2_ = Marshaling<std::vector<CasADi::SX >,std::vector<CasADi::SX* > *>::marshal(x2);++ return new CasADi::Matrix< CasADi::SX >( CasADi::Matrix< CasADi::SX >::sparse(x0_, x1_, x2_) );+}+++// ================== Static method: "sparse'''" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::sparse'''"+// cWrapperName: "CasADi__Matrix_CasADi__SX___sparse_TIC_TIC_TIC"+// protoArgs: "(std::vector<int > * x0, std::vector<int > * x1, std::vector<CasADi::SX* > * x2, int x3, int x4)"+// args: "(x0_, x1_, x2_, x3_, x4_)"+// rettype: Val (NonVec (CasadiClass SXMatrix))+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___sparse_TIC_TIC_TIC(std::vector<int > * x0, std::vector<int > * x1, std::vector<CasADi::SX* > * x2, int x3, int x4)"+// call: "CasADi::Matrix< CasADi::SX >::sparse(x0_, x1_, x2_, x3_, x4_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___sparse_TIC_TIC_TIC(std::vector<int > * x0, std::vector<int > * x1, std::vector<CasADi::SX* > * x2, int x3, int x4);+CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___sparse_TIC_TIC_TIC(std::vector<int > * x0, std::vector<int > * x1, std::vector<CasADi::SX* > * x2, int x3, int x4){+ std::vector<int > x0_ = Marshaling<std::vector<int >,std::vector<int > *>::marshal(x0);+ std::vector<int > x1_ = Marshaling<std::vector<int >,std::vector<int > *>::marshal(x1);+ std::vector<CasADi::SX > x2_ = Marshaling<std::vector<CasADi::SX >,std::vector<CasADi::SX* > *>::marshal(x2);+ int x3_ = Marshaling<int,int>::marshal(x3);+ int x4_ = Marshaling<int,int>::marshal(x4);++ return new CasADi::Matrix< CasADi::SX >( CasADi::Matrix< CasADi::SX >::sparse(x0_, x1_, x2_, x3_, x4_) );+}+++// ================== Static method: "zeros" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::zeros"+// cWrapperName: "CasADi__Matrix_CasADi__SX___zeros"+// protoArgs: "(CasADi::CRSSparsity* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass SXMatrix))+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___zeros(CasADi::CRSSparsity* x0)"+// call: "CasADi::Matrix< CasADi::SX >::zeros(x0_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___zeros(CasADi::CRSSparsity* x0);+CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___zeros(CasADi::CRSSparsity* x0){+ CasADi::CRSSparsity x0_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x0);++ return new CasADi::Matrix< CasADi::SX >( CasADi::Matrix< CasADi::SX >::zeros(x0_) );+}+++// ================== Static method: "zeros'" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::zeros'"+// cWrapperName: "CasADi__Matrix_CasADi__SX___zeros_TIC"+// protoArgs: "(int x0, int x1)"+// args: "(x0_, x1_)"+// rettype: Val (NonVec (CasadiClass SXMatrix))+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___zeros_TIC(int x0, int x1)"+// call: "CasADi::Matrix< CasADi::SX >::zeros(x0_, x1_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___zeros_TIC(int x0, int x1);+CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___zeros_TIC(int x0, int x1){+ int x0_ = Marshaling<int,int>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);++ return new CasADi::Matrix< CasADi::SX >( CasADi::Matrix< CasADi::SX >::zeros(x0_, x1_) );+}+++// ================== Static method: "zeros''" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::zeros''"+// cWrapperName: "CasADi__Matrix_CasADi__SX___zeros_TIC_TIC"+// protoArgs: "(int x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass SXMatrix))+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___zeros_TIC_TIC(int x0)"+// call: "CasADi::Matrix< CasADi::SX >::zeros(x0_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___zeros_TIC_TIC(int x0);+CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___zeros_TIC_TIC(int x0){+ int x0_ = Marshaling<int,int>::marshal(x0);++ return new CasADi::Matrix< CasADi::SX >( CasADi::Matrix< CasADi::SX >::zeros(x0_) );+}+++// ================== Static method: "ones" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::ones"+// cWrapperName: "CasADi__Matrix_CasADi__SX___ones"+// protoArgs: "(CasADi::CRSSparsity* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass SXMatrix))+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___ones(CasADi::CRSSparsity* x0)"+// call: "CasADi::Matrix< CasADi::SX >::ones(x0_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___ones(CasADi::CRSSparsity* x0);+CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___ones(CasADi::CRSSparsity* x0){+ CasADi::CRSSparsity x0_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x0);++ return new CasADi::Matrix< CasADi::SX >( CasADi::Matrix< CasADi::SX >::ones(x0_) );+}+++// ================== Static method: "ones'" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::ones'"+// cWrapperName: "CasADi__Matrix_CasADi__SX___ones_TIC"+// protoArgs: "(int x0, int x1)"+// args: "(x0_, x1_)"+// rettype: Val (NonVec (CasadiClass SXMatrix))+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___ones_TIC(int x0, int x1)"+// call: "CasADi::Matrix< CasADi::SX >::ones(x0_, x1_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___ones_TIC(int x0, int x1);+CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___ones_TIC(int x0, int x1){+ int x0_ = Marshaling<int,int>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);++ return new CasADi::Matrix< CasADi::SX >( CasADi::Matrix< CasADi::SX >::ones(x0_, x1_) );+}+++// ================== Static method: "ones''" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::ones''"+// cWrapperName: "CasADi__Matrix_CasADi__SX___ones_TIC_TIC"+// protoArgs: "(int x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass SXMatrix))+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___ones_TIC_TIC(int x0)"+// call: "CasADi::Matrix< CasADi::SX >::ones(x0_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___ones_TIC_TIC(int x0);+CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___ones_TIC_TIC(int x0){+ int x0_ = Marshaling<int,int>::marshal(x0);++ return new CasADi::Matrix< CasADi::SX >( CasADi::Matrix< CasADi::SX >::ones(x0_) );+}+++// ================== Static method: "inf" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::inf"+// cWrapperName: "CasADi__Matrix_CasADi__SX___inf"+// protoArgs: "(CasADi::CRSSparsity* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass SXMatrix))+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___inf(CasADi::CRSSparsity* x0)"+// call: "CasADi::Matrix< CasADi::SX >::inf(x0_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___inf(CasADi::CRSSparsity* x0);+CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___inf(CasADi::CRSSparsity* x0){+ CasADi::CRSSparsity x0_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x0);++ return new CasADi::Matrix< CasADi::SX >( CasADi::Matrix< CasADi::SX >::inf(x0_) );+}+++// ================== Static method: "inf'" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::inf'"+// cWrapperName: "CasADi__Matrix_CasADi__SX___inf_TIC"+// protoArgs: "(int x0, int x1)"+// args: "(x0_, x1_)"+// rettype: Val (NonVec (CasadiClass SXMatrix))+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___inf_TIC(int x0, int x1)"+// call: "CasADi::Matrix< CasADi::SX >::inf(x0_, x1_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___inf_TIC(int x0, int x1);+CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___inf_TIC(int x0, int x1){+ int x0_ = Marshaling<int,int>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);++ return new CasADi::Matrix< CasADi::SX >( CasADi::Matrix< CasADi::SX >::inf(x0_, x1_) );+}+++// ================== Static method: "inf''" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::inf''"+// cWrapperName: "CasADi__Matrix_CasADi__SX___inf_TIC_TIC"+// protoArgs: "(int x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass SXMatrix))+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___inf_TIC_TIC(int x0)"+// call: "CasADi::Matrix< CasADi::SX >::inf(x0_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___inf_TIC_TIC(int x0);+CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___inf_TIC_TIC(int x0){+ int x0_ = Marshaling<int,int>::marshal(x0);++ return new CasADi::Matrix< CasADi::SX >( CasADi::Matrix< CasADi::SX >::inf(x0_) );+}+++// ================== Static method: "inf'''" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::inf'''"+// cWrapperName: "CasADi__Matrix_CasADi__SX___inf_TIC_TIC_TIC"+// protoArgs: "()"+// args: "()"+// rettype: Val (NonVec (CasadiClass SXMatrix))+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___inf_TIC_TIC_TIC()"+// call: "CasADi::Matrix< CasADi::SX >::inf()"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___inf_TIC_TIC_TIC();+CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___inf_TIC_TIC_TIC(){++ return new CasADi::Matrix< CasADi::SX >( CasADi::Matrix< CasADi::SX >::inf() );+}+++// ================== Static method: "nan" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::nan"+// cWrapperName: "CasADi__Matrix_CasADi__SX___nan"+// protoArgs: "(CasADi::CRSSparsity* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass SXMatrix))+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___nan(CasADi::CRSSparsity* x0)"+// call: "CasADi::Matrix< CasADi::SX >::nan(x0_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___nan(CasADi::CRSSparsity* x0);+CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___nan(CasADi::CRSSparsity* x0){+ CasADi::CRSSparsity x0_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x0);++ return new CasADi::Matrix< CasADi::SX >( CasADi::Matrix< CasADi::SX >::nan(x0_) );+}+++// ================== Static method: "nan'" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::nan'"+// cWrapperName: "CasADi__Matrix_CasADi__SX___nan_TIC"+// protoArgs: "(int x0, int x1)"+// args: "(x0_, x1_)"+// rettype: Val (NonVec (CasadiClass SXMatrix))+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___nan_TIC(int x0, int x1)"+// call: "CasADi::Matrix< CasADi::SX >::nan(x0_, x1_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___nan_TIC(int x0, int x1);+CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___nan_TIC(int x0, int x1){+ int x0_ = Marshaling<int,int>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);++ return new CasADi::Matrix< CasADi::SX >( CasADi::Matrix< CasADi::SX >::nan(x0_, x1_) );+}+++// ================== Static method: "nan''" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::nan''"+// cWrapperName: "CasADi__Matrix_CasADi__SX___nan_TIC_TIC"+// protoArgs: "(int x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass SXMatrix))+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___nan_TIC_TIC(int x0)"+// call: "CasADi::Matrix< CasADi::SX >::nan(x0_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___nan_TIC_TIC(int x0);+CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___nan_TIC_TIC(int x0){+ int x0_ = Marshaling<int,int>::marshal(x0);++ return new CasADi::Matrix< CasADi::SX >( CasADi::Matrix< CasADi::SX >::nan(x0_) );+}+++// ================== Static method: "nan'''" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::nan'''"+// cWrapperName: "CasADi__Matrix_CasADi__SX___nan_TIC_TIC_TIC"+// protoArgs: "()"+// args: "()"+// rettype: Val (NonVec (CasadiClass SXMatrix))+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___nan_TIC_TIC_TIC()"+// call: "CasADi::Matrix< CasADi::SX >::nan()"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___nan_TIC_TIC_TIC();+CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___nan_TIC_TIC_TIC(){++ return new CasADi::Matrix< CasADi::SX >( CasADi::Matrix< CasADi::SX >::nan() );+}+++// ================== Static method: "repmat" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::repmat"+// cWrapperName: "CasADi__Matrix_CasADi__SX___repmat"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, int x1, int x2)"+// args: "(x0_, x1_, x2_)"+// rettype: Val (NonVec (CasadiClass SXMatrix))+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___repmat(CasADi::Matrix< CasADi::SX >* x0, int x1, int x2)"+// call: "CasADi::Matrix< CasADi::SX >::repmat(x0_, x1_, x2_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___repmat(CasADi::Matrix< CasADi::SX >* x0, int x1, int x2);+CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___repmat(CasADi::Matrix< CasADi::SX >* x0, int x1, int x2){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);+ int x2_ = Marshaling<int,int>::marshal(x2);++ return new CasADi::Matrix< CasADi::SX >( CasADi::Matrix< CasADi::SX >::repmat(x0_, x1_, x2_) );+}+++// ================== Static method: "repmat'" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::repmat'"+// cWrapperName: "CasADi__Matrix_CasADi__SX___repmat_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, int x1)"+// args: "(x0_, x1_)"+// rettype: Val (NonVec (CasadiClass SXMatrix))+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___repmat_TIC(CasADi::Matrix< CasADi::SX >* x0, int x1)"+// call: "CasADi::Matrix< CasADi::SX >::repmat(x0_, x1_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___repmat_TIC(CasADi::Matrix< CasADi::SX >* x0, int x1);+CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___repmat_TIC(CasADi::Matrix< CasADi::SX >* x0, int x1){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);++ return new CasADi::Matrix< CasADi::SX >( CasADi::Matrix< CasADi::SX >::repmat(x0_, x1_) );+}+++// ================== Static method: "eye" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::eye"+// cWrapperName: "CasADi__Matrix_CasADi__SX___eye"+// protoArgs: "(int x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass SXMatrix))+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___eye(int x0)"+// call: "CasADi::Matrix< CasADi::SX >::eye(x0_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___eye(int x0);+CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___eye(int x0){+ int x0_ = Marshaling<int,int>::marshal(x0);++ return new CasADi::Matrix< CasADi::SX >( CasADi::Matrix< CasADi::SX >::eye(x0_) );+}+++// ================== Normal method: "isNull" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::isNull"+// cWrapperName: "CasADi__Matrix_CasADi__SX___isNull"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* obj)"+// args: "()"+// rettype: Val (NonVec CBool)+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__Matrix_CasADi__SX___isNull(CasADi::Matrix< CasADi::SX >* obj)"+// call: "obj->isNull()"+extern "C"+ bool* CasADi__Matrix_CasADi__SX___isNull(CasADi::Matrix< CasADi::SX >* obj);+bool* CasADi__Matrix_CasADi__SX___isNull(CasADi::Matrix< CasADi::SX >* obj){++ return new bool( obj->isNull() );+}+++// ================== Static method: "setPrecision" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::setPrecision"+// cWrapperName: "CasADi__Matrix_CasADi__SX___setPrecision"+// protoArgs: "(int x0)"+// args: "(x0_)"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__Matrix_CasADi__SX___setPrecision(int x0)"+// call: "CasADi::Matrix< CasADi::SX >::setPrecision(x0_)"+extern "C"+ void CasADi__Matrix_CasADi__SX___setPrecision(int x0);+void CasADi__Matrix_CasADi__SX___setPrecision(int x0){+ int x0_ = Marshaling<int,int>::marshal(x0);++ return CasADi::Matrix< CasADi::SX >::setPrecision(x0_);+}+++// ================== Static method: "setWidth" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::setWidth"+// cWrapperName: "CasADi__Matrix_CasADi__SX___setWidth"+// protoArgs: "(int x0)"+// args: "(x0_)"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__Matrix_CasADi__SX___setWidth(int x0)"+// call: "CasADi::Matrix< CasADi::SX >::setWidth(x0_)"+extern "C"+ void CasADi__Matrix_CasADi__SX___setWidth(int x0);+void CasADi__Matrix_CasADi__SX___setWidth(int x0){+ int x0_ = Marshaling<int,int>::marshal(x0);++ return CasADi::Matrix< CasADi::SX >::setWidth(x0_);+}+++// ================== Static method: "setScientific" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >::setScientific"+// cWrapperName: "CasADi__Matrix_CasADi__SX___setScientific"+// protoArgs: "(bool* x0)"+// args: "(x0_)"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__Matrix_CasADi__SX___setScientific(bool* x0)"+// call: "CasADi::Matrix< CasADi::SX >::setScientific(x0_)"+extern "C"+ void CasADi__Matrix_CasADi__SX___setScientific(bool* x0);+void CasADi__Matrix_CasADi__SX___setScientific(bool* x0){+ bool x0_ = Marshaling<bool,bool*>::marshal(x0);++ return CasADi::Matrix< CasADi::SX >::setScientific(x0_);+}+++// ================== Constructor method: "SXMatrix" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >"+// cWrapperName: "CasADi__Matrix_CasADi__SX___SXMatrix"+// protoArgs: "()"+// args: "()"+// rettype: Val (NonVec (CasadiClass SXMatrix))+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___SXMatrix()"+// call: "CasADi::Matrix< CasADi::SX >()"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___SXMatrix();+CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___SXMatrix(){++ return new CasADi::Matrix< CasADi::SX >( CasADi::Matrix< CasADi::SX >() );+}+++// ================== Constructor method: "SXMatrix'" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >"+// cWrapperName: "CasADi__Matrix_CasADi__SX___SXMatrix_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass SXMatrix))+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___SXMatrix_TIC(CasADi::Matrix< CasADi::SX >* x0)"+// call: "CasADi::Matrix< CasADi::SX >(x0_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___SXMatrix_TIC(CasADi::Matrix< CasADi::SX >* x0);+CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___SXMatrix_TIC(CasADi::Matrix< CasADi::SX >* x0){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);++ return new CasADi::Matrix< CasADi::SX >( CasADi::Matrix< CasADi::SX >(x0_) );+}+++// ================== Constructor method: "SXMatrix''" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >"+// cWrapperName: "CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC"+// protoArgs: "(int x0, int x1)"+// args: "(x0_, x1_)"+// rettype: Val (NonVec (CasadiClass SXMatrix))+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC(int x0, int x1)"+// call: "CasADi::Matrix< CasADi::SX >(x0_, x1_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC(int x0, int x1);+CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC(int x0, int x1){+ int x0_ = Marshaling<int,int>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);++ return new CasADi::Matrix< CasADi::SX >( CasADi::Matrix< CasADi::SX >(x0_, x1_) );+}+++// ================== Constructor method: "SXMatrix'''" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >"+// cWrapperName: "CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC"+// protoArgs: "(int x0, int x1, CasADi::SX* x2)"+// args: "(x0_, x1_, x2_)"+// rettype: Val (NonVec (CasadiClass SXMatrix))+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC(int x0, int x1, CasADi::SX* x2)"+// call: "CasADi::Matrix< CasADi::SX >(x0_, x1_, x2_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC(int x0, int x1, CasADi::SX* x2);+CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC(int x0, int x1, CasADi::SX* x2){+ int x0_ = Marshaling<int,int>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);+ CasADi::SX x2_ = Marshaling<CasADi::SX,CasADi::SX*>::marshal(x2);++ return new CasADi::Matrix< CasADi::SX >( CasADi::Matrix< CasADi::SX >(x0_, x1_, x2_) );+}+++// ================== Constructor method: "SXMatrix''''" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >"+// cWrapperName: "CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC"+// protoArgs: "(int x0, int x1, std::vector<int > * x2, std::vector<int > * x3, std::vector<CasADi::SX* > * x4)"+// args: "(x0_, x1_, x2_, x3_, x4_)"+// rettype: Val (NonVec (CasadiClass SXMatrix))+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC(int x0, int x1, std::vector<int > * x2, std::vector<int > * x3, std::vector<CasADi::SX* > * x4)"+// call: "CasADi::Matrix< CasADi::SX >(x0_, x1_, x2_, x3_, x4_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC(int x0, int x1, std::vector<int > * x2, std::vector<int > * x3, std::vector<CasADi::SX* > * x4);+CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC(int x0, int x1, std::vector<int > * x2, std::vector<int > * x3, std::vector<CasADi::SX* > * x4){+ int x0_ = Marshaling<int,int>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);+ std::vector<int > x2_ = Marshaling<std::vector<int >,std::vector<int > *>::marshal(x2);+ std::vector<int > x3_ = Marshaling<std::vector<int >,std::vector<int > *>::marshal(x3);+ std::vector<CasADi::SX > x4_ = Marshaling<std::vector<CasADi::SX >,std::vector<CasADi::SX* > *>::marshal(x4);++ return new CasADi::Matrix< CasADi::SX >( CasADi::Matrix< CasADi::SX >(x0_, x1_, x2_, x3_, x4_) );+}+++// ================== Constructor method: "SXMatrix'''''" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >"+// cWrapperName: "CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC"+// protoArgs: "(int x0, int x1, std::vector<int > * x2, std::vector<int > * x3)"+// args: "(x0_, x1_, x2_, x3_)"+// rettype: Val (NonVec (CasadiClass SXMatrix))+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC(int x0, int x1, std::vector<int > * x2, std::vector<int > * x3)"+// call: "CasADi::Matrix< CasADi::SX >(x0_, x1_, x2_, x3_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC(int x0, int x1, std::vector<int > * x2, std::vector<int > * x3);+CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC(int x0, int x1, std::vector<int > * x2, std::vector<int > * x3){+ int x0_ = Marshaling<int,int>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);+ std::vector<int > x2_ = Marshaling<std::vector<int >,std::vector<int > *>::marshal(x2);+ std::vector<int > x3_ = Marshaling<std::vector<int >,std::vector<int > *>::marshal(x3);++ return new CasADi::Matrix< CasADi::SX >( CasADi::Matrix< CasADi::SX >(x0_, x1_, x2_, x3_) );+}+++// ================== Constructor method: "SXMatrix''''''" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >"+// cWrapperName: "CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC_TIC"+// protoArgs: "(std::vector<std::vector<CasADi::SX* > > * x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass SXMatrix))+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC_TIC(std::vector<std::vector<CasADi::SX* > > * x0)"+// call: "CasADi::Matrix< CasADi::SX >(x0_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC_TIC(std::vector<std::vector<CasADi::SX* > > * x0);+CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC_TIC(std::vector<std::vector<CasADi::SX* > > * x0){+ std::vector<std::vector<CasADi::SX > > x0_ = Marshaling<std::vector<std::vector<CasADi::SX > >,std::vector<std::vector<CasADi::SX* > > *>::marshal(x0);++ return new CasADi::Matrix< CasADi::SX >( CasADi::Matrix< CasADi::SX >(x0_) );+}+++// ================== Constructor method: "SXMatrix'''''''" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >"+// cWrapperName: "CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC"+// protoArgs: "(CasADi::CRSSparsity* x0, CasADi::SX* x1)"+// args: "(x0_, x1_)"+// rettype: Val (NonVec (CasadiClass SXMatrix))+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::CRSSparsity* x0, CasADi::SX* x1)"+// call: "CasADi::Matrix< CasADi::SX >(x0_, x1_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::CRSSparsity* x0, CasADi::SX* x1);+CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::CRSSparsity* x0, CasADi::SX* x1){+ CasADi::CRSSparsity x0_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x0);+ CasADi::SX x1_ = Marshaling<CasADi::SX,CasADi::SX*>::marshal(x1);++ return new CasADi::Matrix< CasADi::SX >( CasADi::Matrix< CasADi::SX >(x0_, x1_) );+}+++// ================== Constructor method: "SXMatrix''''''''" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >"+// cWrapperName: "CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"+// protoArgs: "(CasADi::CRSSparsity* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass SXMatrix))+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::CRSSparsity* x0)"+// call: "CasADi::Matrix< CasADi::SX >(x0_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::CRSSparsity* x0);+CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::CRSSparsity* x0){+ CasADi::CRSSparsity x0_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x0);++ return new CasADi::Matrix< CasADi::SX >( CasADi::Matrix< CasADi::SX >(x0_) );+}+++// ================== Constructor method: "SXMatrix'''''''''" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >"+// cWrapperName: "CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"+// protoArgs: "(CasADi::CRSSparsity* x0, std::vector<CasADi::SX* > * x1)"+// args: "(x0_, x1_)"+// rettype: Val (NonVec (CasadiClass SXMatrix))+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::CRSSparsity* x0, std::vector<CasADi::SX* > * x1)"+// call: "CasADi::Matrix< CasADi::SX >(x0_, x1_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::CRSSparsity* x0, std::vector<CasADi::SX* > * x1);+CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::CRSSparsity* x0, std::vector<CasADi::SX* > * x1){+ CasADi::CRSSparsity x0_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x0);+ std::vector<CasADi::SX > x1_ = Marshaling<std::vector<CasADi::SX >,std::vector<CasADi::SX* > *>::marshal(x1);++ return new CasADi::Matrix< CasADi::SX >( CasADi::Matrix< CasADi::SX >(x0_, x1_) );+}+++// ================== Constructor method: "SXMatrix''''''''''" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >"+// cWrapperName: "CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"+// protoArgs: "(double x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass SXMatrix))+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(double x0)"+// call: "CasADi::Matrix< CasADi::SX >(x0_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(double x0);+CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(double x0){+ double x0_ = Marshaling<double,double>::marshal(x0);++ return new CasADi::Matrix< CasADi::SX >( CasADi::Matrix< CasADi::SX >(x0_) );+}+++// ================== Constructor method: "SXMatrix'''''''''''" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >"+// cWrapperName: "CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"+// protoArgs: "(std::vector<CasADi::SX* > * x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass SXMatrix))+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector<CasADi::SX* > * x0)"+// call: "CasADi::Matrix< CasADi::SX >(x0_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector<CasADi::SX* > * x0);+CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector<CasADi::SX* > * x0){+ std::vector<CasADi::SX > x0_ = Marshaling<std::vector<CasADi::SX >,std::vector<CasADi::SX* > *>::marshal(x0);++ return new CasADi::Matrix< CasADi::SX >( CasADi::Matrix< CasADi::SX >(x0_) );+}+++// ================== Constructor method: "SXMatrix''''''''''''" ===============+// class: "CasADi::Matrix< CasADi::SX >"+// cppName: "CasADi::Matrix< CasADi::SX >"+// cWrapperName: "CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"+// protoArgs: "(std::vector<CasADi::SX* > * x0, int x1, int x2)"+// args: "(x0_, x1_, x2_)"+// rettype: Val (NonVec (CasadiClass SXMatrix))+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector<CasADi::SX* > * x0, int x1, int x2)"+// call: "CasADi::Matrix< CasADi::SX >(x0_, x1_, x2_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector<CasADi::SX* > * x0, int x1, int x2);+CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector<CasADi::SX* > * x0, int x1, int x2){+ std::vector<CasADi::SX > x0_ = Marshaling<std::vector<CasADi::SX >,std::vector<CasADi::SX* > *>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);+ int x2_ = Marshaling<int,int>::marshal(x2);++ return new CasADi::Matrix< CasADi::SX >( CasADi::Matrix< CasADi::SX >(x0_, x1_, x2_) );+}+++// ================== delete CasadiClass IOScheme===============+// classType: CasadiClass IOScheme+extern "C"+ void delete_CasADi__IOScheme(CasADi::IOScheme* obj);+void delete_CasADi__IOScheme(CasADi::IOScheme* obj){+ delete obj;+}+extern "C"+ void delete_std__vector_CasADi__IOScheme_(std::vector<CasADi::IOScheme* >* obj);+void delete_std__vector_CasADi__IOScheme_(std::vector<CasADi::IOScheme* >* obj){+ delete obj;+}+extern "C"+ void delete_std__vector_std__vector_CasADi__IOScheme__(std::vector<std::vector<CasADi::IOScheme* > >* obj);+void delete_std__vector_std__vector_CasADi__IOScheme__(std::vector<std::vector<CasADi::IOScheme* > >* obj){+ delete obj;+}+extern "C"+ void delete_std__vector_std__vector_std__vector_CasADi__IOScheme___(std::vector<std::vector<std::vector<CasADi::IOScheme* > > >* obj);+void delete_std__vector_std__vector_std__vector_CasADi__IOScheme___(std::vector<std::vector<std::vector<CasADi::IOScheme* > > >* obj){+ delete obj;+}++// ================== Normal method: "checkNode" ===============+// class: "CasADi::IOScheme"+// cppName: "CasADi::IOScheme::checkNode"+// cWrapperName: "CasADi__IOScheme__checkNode"+// protoArgs: "(CasADi::IOScheme* obj)"+// args: "()"+// rettype: Val (NonVec CBool)+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__IOScheme__checkNode(CasADi::IOScheme* obj)"+// call: "obj->checkNode()"+extern "C"+ bool* CasADi__IOScheme__checkNode(CasADi::IOScheme* obj);+bool* CasADi__IOScheme__checkNode(CasADi::IOScheme* obj){++ return new bool( obj->checkNode() );+}+++// ================== Normal method: "name" ===============+// class: "CasADi::IOScheme"+// cppName: "CasADi::IOScheme::name"+// cWrapperName: "CasADi__IOScheme__name"+// protoArgs: "(CasADi::IOScheme* obj)"+// args: "()"+// rettype: Val (NonVec StdString)+// cWrapperRetType: "std::string*"+// proto: "std::string* CasADi__IOScheme__name(CasADi::IOScheme* obj)"+// call: "obj->name()"+extern "C"+ std::string* CasADi__IOScheme__name(CasADi::IOScheme* obj);+std::string* CasADi__IOScheme__name(CasADi::IOScheme* obj){++ return new std::string( obj->name() );+}+++// ================== Normal method: "entryNames" ===============+// class: "CasADi::IOScheme"+// cppName: "CasADi::IOScheme::entryNames"+// cWrapperName: "CasADi__IOScheme__entryNames"+// protoArgs: "(CasADi::IOScheme* obj)"+// args: "()"+// rettype: Val (NonVec StdString)+// cWrapperRetType: "std::string*"+// proto: "std::string* CasADi__IOScheme__entryNames(CasADi::IOScheme* obj)"+// call: "obj->entryNames()"+extern "C"+ std::string* CasADi__IOScheme__entryNames(CasADi::IOScheme* obj);+std::string* CasADi__IOScheme__entryNames(CasADi::IOScheme* obj){++ return new std::string( obj->entryNames() );+}+++// ================== Normal method: "index" ===============+// class: "CasADi::IOScheme"+// cppName: "CasADi::IOScheme::index"+// cWrapperName: "CasADi__IOScheme__index"+// protoArgs: "(CasADi::IOScheme* obj, std::string* x0)"+// args: "(x0_)"+// rettype: Val (NonVec CInt)+// cWrapperRetType: "int"+// proto: "int CasADi__IOScheme__index(CasADi::IOScheme* obj, std::string* x0)"+// call: "obj->index(x0_)"+extern "C"+ int CasADi__IOScheme__index(CasADi::IOScheme* obj, std::string* x0);+int CasADi__IOScheme__index(CasADi::IOScheme* obj, std::string* x0){+ std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);++ return obj->index(x0_);+}+++// ================== Normal method: "size" ===============+// class: "CasADi::IOScheme"+// cppName: "CasADi::IOScheme::size"+// cWrapperName: "CasADi__IOScheme__size"+// protoArgs: "(CasADi::IOScheme* obj)"+// args: "()"+// rettype: Val (NonVec CInt)+// cWrapperRetType: "int"+// proto: "int CasADi__IOScheme__size(CasADi::IOScheme* obj)"+// call: "obj->size()"+extern "C"+ int CasADi__IOScheme__size(CasADi::IOScheme* obj);+int CasADi__IOScheme__size(CasADi::IOScheme* obj){++ return obj->size();+}+++// ================== Normal method: "entry" ===============+// class: "CasADi::IOScheme"+// cppName: "CasADi::IOScheme::entry"+// cWrapperName: "CasADi__IOScheme__entry"+// protoArgs: "(CasADi::IOScheme* obj, int x0)"+// args: "(x0_)"+// rettype: Val (NonVec StdString)+// cWrapperRetType: "std::string*"+// proto: "std::string* CasADi__IOScheme__entry(CasADi::IOScheme* obj, int x0)"+// call: "obj->entry(x0_)"+extern "C"+ std::string* CasADi__IOScheme__entry(CasADi::IOScheme* obj, int x0);+std::string* CasADi__IOScheme__entry(CasADi::IOScheme* obj, int x0){+ int x0_ = Marshaling<int,int>::marshal(x0);++ return new std::string( obj->entry(x0_) );+}+++// ================== Normal method: "entryLabel" ===============+// class: "CasADi::IOScheme"+// cppName: "CasADi::IOScheme::entryLabel"+// cWrapperName: "CasADi__IOScheme__entryLabel"+// protoArgs: "(CasADi::IOScheme* obj, int x0)"+// args: "(x0_)"+// rettype: Val (NonVec StdString)+// cWrapperRetType: "std::string*"+// proto: "std::string* CasADi__IOScheme__entryLabel(CasADi::IOScheme* obj, int x0)"+// call: "obj->entryLabel(x0_)"+extern "C"+ std::string* CasADi__IOScheme__entryLabel(CasADi::IOScheme* obj, int x0);+std::string* CasADi__IOScheme__entryLabel(CasADi::IOScheme* obj, int x0){+ int x0_ = Marshaling<int,int>::marshal(x0);++ return new std::string( obj->entryLabel(x0_) );+}+++// ================== Normal method: "entryEnum" ===============+// class: "CasADi::IOScheme"+// cppName: "CasADi::IOScheme::entryEnum"+// cWrapperName: "CasADi__IOScheme__entryEnum"+// protoArgs: "(CasADi::IOScheme* obj, int x0)"+// args: "(x0_)"+// rettype: Val (NonVec StdString)+// cWrapperRetType: "std::string*"+// proto: "std::string* CasADi__IOScheme__entryEnum(CasADi::IOScheme* obj, int x0)"+// call: "obj->entryEnum(x0_)"+extern "C"+ std::string* CasADi__IOScheme__entryEnum(CasADi::IOScheme* obj, int x0);+std::string* CasADi__IOScheme__entryEnum(CasADi::IOScheme* obj, int x0){+ int x0_ = Marshaling<int,int>::marshal(x0);++ return new std::string( obj->entryEnum(x0_) );+}+++// ================== Normal method: "describeInput" ===============+// class: "CasADi::IOScheme"+// cppName: "CasADi::IOScheme::describeInput"+// cWrapperName: "CasADi__IOScheme__describeInput"+// protoArgs: "(CasADi::IOScheme* obj, int x0)"+// args: "(x0_)"+// rettype: Val (NonVec StdString)+// cWrapperRetType: "std::string*"+// proto: "std::string* CasADi__IOScheme__describeInput(CasADi::IOScheme* obj, int x0)"+// call: "obj->describeInput(x0_)"+extern "C"+ std::string* CasADi__IOScheme__describeInput(CasADi::IOScheme* obj, int x0);+std::string* CasADi__IOScheme__describeInput(CasADi::IOScheme* obj, int x0){+ int x0_ = Marshaling<int,int>::marshal(x0);++ return new std::string( obj->describeInput(x0_) );+}+++// ================== Normal method: "describeOutput" ===============+// class: "CasADi::IOScheme"+// cppName: "CasADi::IOScheme::describeOutput"+// cWrapperName: "CasADi__IOScheme__describeOutput"+// protoArgs: "(CasADi::IOScheme* obj, int x0)"+// args: "(x0_)"+// rettype: Val (NonVec StdString)+// cWrapperRetType: "std::string*"+// proto: "std::string* CasADi__IOScheme__describeOutput(CasADi::IOScheme* obj, int x0)"+// call: "obj->describeOutput(x0_)"+extern "C"+ std::string* CasADi__IOScheme__describeOutput(CasADi::IOScheme* obj, int x0);+std::string* CasADi__IOScheme__describeOutput(CasADi::IOScheme* obj, int x0){+ int x0_ = Marshaling<int,int>::marshal(x0);++ return new std::string( obj->describeOutput(x0_) );+}+++// ================== Normal method: "describe" ===============+// class: "CasADi::IOScheme"+// cppName: "CasADi::IOScheme::describe"+// cWrapperName: "CasADi__IOScheme__describe"+// protoArgs: "(CasADi::IOScheme* obj, int x0)"+// args: "(x0_)"+// rettype: Val (NonVec StdString)+// cWrapperRetType: "std::string*"+// proto: "std::string* CasADi__IOScheme__describe(CasADi::IOScheme* obj, int x0)"+// call: "obj->describe(x0_)"+extern "C"+ std::string* CasADi__IOScheme__describe(CasADi::IOScheme* obj, int x0);+std::string* CasADi__IOScheme__describe(CasADi::IOScheme* obj, int x0){+ int x0_ = Marshaling<int,int>::marshal(x0);++ return new std::string( obj->describe(x0_) );+}+++// ================== Normal method: "known" ===============+// class: "CasADi::IOScheme"+// cppName: "CasADi::IOScheme::known"+// cWrapperName: "CasADi__IOScheme__known"+// protoArgs: "(CasADi::IOScheme* obj)"+// args: "()"+// rettype: Val (NonVec CBool)+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__IOScheme__known(CasADi::IOScheme* obj)"+// call: "obj->known()"+extern "C"+ bool* CasADi__IOScheme__known(CasADi::IOScheme* obj);+bool* CasADi__IOScheme__known(CasADi::IOScheme* obj){++ return new bool( obj->known() );+}+++// ================== Normal method: "compatibleSize" ===============+// class: "CasADi::IOScheme"+// cppName: "CasADi::IOScheme::compatibleSize"+// cWrapperName: "CasADi__IOScheme__compatibleSize"+// protoArgs: "(CasADi::IOScheme* obj, int x0)"+// args: "(x0_)"+// rettype: Val (NonVec CInt)+// cWrapperRetType: "int"+// proto: "int CasADi__IOScheme__compatibleSize(CasADi::IOScheme* obj, int x0)"+// call: "obj->compatibleSize(x0_)"+extern "C"+ int CasADi__IOScheme__compatibleSize(CasADi::IOScheme* obj, int x0);+int CasADi__IOScheme__compatibleSize(CasADi::IOScheme* obj, int x0){+ int x0_ = Marshaling<int,int>::marshal(x0);++ return obj->compatibleSize(x0_);+}+++// ================== Constructor method: "IOScheme" ===============+// class: "CasADi::IOScheme"+// cppName: "CasADi::IOScheme"+// cWrapperName: "CasADi__IOScheme__IOScheme"+// protoArgs: "()"+// args: "()"+// rettype: Val (NonVec (CasadiClass IOScheme))+// cWrapperRetType: "CasADi::IOScheme*"+// proto: "CasADi::IOScheme* CasADi__IOScheme__IOScheme()"+// call: "CasADi::IOScheme()"+extern "C"+ CasADi::IOScheme* CasADi__IOScheme__IOScheme();+CasADi::IOScheme* CasADi__IOScheme__IOScheme(){++ return new CasADi::IOScheme( CasADi::IOScheme() );+}+++// ================== Constructor method: "IOScheme'" ===============+// class: "CasADi::IOScheme"+// cppName: "CasADi::IOScheme"+// cWrapperName: "CasADi__IOScheme__IOScheme_TIC"+// protoArgs: "(CasADi::InputOutputScheme x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass IOScheme))+// cWrapperRetType: "CasADi::IOScheme*"+// proto: "CasADi::IOScheme* CasADi__IOScheme__IOScheme_TIC(CasADi::InputOutputScheme x0)"+// call: "CasADi::IOScheme(x0_)"+extern "C"+ CasADi::IOScheme* CasADi__IOScheme__IOScheme_TIC(CasADi::InputOutputScheme x0);+CasADi::IOScheme* CasADi__IOScheme__IOScheme_TIC(CasADi::InputOutputScheme x0){+ CasADi::InputOutputScheme x0_ = Marshaling<CasADi::InputOutputScheme,CasADi::InputOutputScheme>::marshal(x0);++ return new CasADi::IOScheme( CasADi::IOScheme(x0_) );+}+++// ================== Constructor method: "IOScheme''" ===============+// class: "CasADi::IOScheme"+// cppName: "CasADi::IOScheme"+// cWrapperName: "CasADi__IOScheme__IOScheme_TIC_TIC"+// protoArgs: "(std::vector<std::string* > * x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass IOScheme))+// cWrapperRetType: "CasADi::IOScheme*"+// proto: "CasADi::IOScheme* CasADi__IOScheme__IOScheme_TIC_TIC(std::vector<std::string* > * x0)"+// call: "CasADi::IOScheme(x0_)"+extern "C"+ CasADi::IOScheme* CasADi__IOScheme__IOScheme_TIC_TIC(std::vector<std::string* > * x0);+CasADi::IOScheme* CasADi__IOScheme__IOScheme_TIC_TIC(std::vector<std::string* > * x0){+ std::vector<std::string > x0_ = Marshaling<std::vector<std::string >,std::vector<std::string* > *>::marshal(x0);++ return new CasADi::IOScheme( CasADi::IOScheme(x0_) );+}+++// ================== delete CasadiClass DMatrix===============+// classType: CasadiClass DMatrix+extern "C"+ void delete_CasADi__Matrix_double_(CasADi::Matrix< double >* obj);+void delete_CasADi__Matrix_double_(CasADi::Matrix< double >* obj){+ delete obj;+}+extern "C"+ void delete_std__vector_CasADi__Matrix_double__(std::vector<CasADi::Matrix< double >* >* obj);+void delete_std__vector_CasADi__Matrix_double__(std::vector<CasADi::Matrix< double >* >* obj){+ delete obj;+}+extern "C"+ void delete_std__vector_std__vector_CasADi__Matrix_double___(std::vector<std::vector<CasADi::Matrix< double >* > >* obj);+void delete_std__vector_std__vector_CasADi__Matrix_double___(std::vector<std::vector<CasADi::Matrix< double >* > >* obj){+ delete obj;+}+extern "C"+ void delete_std__vector_std__vector_std__vector_CasADi__Matrix_double____(std::vector<std::vector<std::vector<CasADi::Matrix< double >* > > >* obj);+void delete_std__vector_std__vector_std__vector_CasADi__Matrix_double____(std::vector<std::vector<std::vector<CasADi::Matrix< double >* > > >* obj){+ delete obj;+}++// ================== Normal method: "size1" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::size1"+// cWrapperName: "CasADi__Matrix_double___size1"+// protoArgs: "(CasADi::Matrix< double >* obj)"+// args: "()"+// rettype: Val (NonVec CInt)+// cWrapperRetType: "int"+// proto: "int CasADi__Matrix_double___size1(CasADi::Matrix< double >* obj)"+// call: "obj->size1()"+extern "C"+ int CasADi__Matrix_double___size1(CasADi::Matrix< double >* obj);+int CasADi__Matrix_double___size1(CasADi::Matrix< double >* obj){++ return obj->size1();+}+++// ================== Normal method: "size2" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::size2"+// cWrapperName: "CasADi__Matrix_double___size2"+// protoArgs: "(CasADi::Matrix< double >* obj)"+// args: "()"+// rettype: Val (NonVec CInt)+// cWrapperRetType: "int"+// proto: "int CasADi__Matrix_double___size2(CasADi::Matrix< double >* obj)"+// call: "obj->size2()"+extern "C"+ int CasADi__Matrix_double___size2(CasADi::Matrix< double >* obj);+int CasADi__Matrix_double___size2(CasADi::Matrix< double >* obj){++ return obj->size2();+}+++// ================== Normal method: "size" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::size"+// cWrapperName: "CasADi__Matrix_double___size"+// protoArgs: "(CasADi::Matrix< double >* obj)"+// args: "()"+// rettype: Val (NonVec CInt)+// cWrapperRetType: "int"+// proto: "int CasADi__Matrix_double___size(CasADi::Matrix< double >* obj)"+// call: "obj->size()"+extern "C"+ int CasADi__Matrix_double___size(CasADi::Matrix< double >* obj);+int CasADi__Matrix_double___size(CasADi::Matrix< double >* obj){++ return obj->size();+}+++// ================== Normal method: "numel" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::numel"+// cWrapperName: "CasADi__Matrix_double___numel"+// protoArgs: "(CasADi::Matrix< double >* obj)"+// args: "()"+// rettype: Val (NonVec CInt)+// cWrapperRetType: "int"+// proto: "int CasADi__Matrix_double___numel(CasADi::Matrix< double >* obj)"+// call: "obj->numel()"+extern "C"+ int CasADi__Matrix_double___numel(CasADi::Matrix< double >* obj);+int CasADi__Matrix_double___numel(CasADi::Matrix< double >* obj){++ return obj->numel();+}+++// ================== Normal method: "sanityCheck" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::sanityCheck"+// cWrapperName: "CasADi__Matrix_double___sanityCheck"+// protoArgs: "(CasADi::Matrix< double >* obj, bool* x0)"+// args: "(x0_)"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__Matrix_double___sanityCheck(CasADi::Matrix< double >* obj, bool* x0)"+// call: "obj->sanityCheck(x0_)"+extern "C"+ void CasADi__Matrix_double___sanityCheck(CasADi::Matrix< double >* obj, bool* x0);+void CasADi__Matrix_double___sanityCheck(CasADi::Matrix< double >* obj, bool* x0){+ bool x0_ = Marshaling<bool,bool*>::marshal(x0);++ return obj->sanityCheck(x0_);+}+++// ================== Normal method: "sanityCheck'" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::sanityCheck'"+// cWrapperName: "CasADi__Matrix_double___sanityCheck_TIC"+// protoArgs: "(CasADi::Matrix< double >* obj)"+// args: "()"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__Matrix_double___sanityCheck_TIC(CasADi::Matrix< double >* obj)"+// call: "obj->sanityCheck()"+extern "C"+ void CasADi__Matrix_double___sanityCheck_TIC(CasADi::Matrix< double >* obj);+void CasADi__Matrix_double___sanityCheck_TIC(CasADi::Matrix< double >* obj){++ return obj->sanityCheck();+}+++// ================== Normal method: "vector" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::vector"+// cWrapperName: "CasADi__Matrix_double___vector"+// protoArgs: "(CasADi::Matrix< double >* obj)"+// args: "()"+// rettype: Val (NonVec CBool)+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__Matrix_double___vector(CasADi::Matrix< double >* obj)"+// call: "obj->vector()"+extern "C"+ bool* CasADi__Matrix_double___vector(CasADi::Matrix< double >* obj);+bool* CasADi__Matrix_double___vector(CasADi::Matrix< double >* obj){++ return new bool( obj->vector() );+}+++// ================== Normal method: "at" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::at"+// cWrapperName: "CasADi__Matrix_double___at"+// protoArgs: "(CasADi::Matrix< double >* obj, int x0)"+// args: "(x0_)"+// rettype: Val (NonVec CDouble)+// cWrapperRetType: "double"+// proto: "double CasADi__Matrix_double___at(CasADi::Matrix< double >* obj, int x0)"+// call: "obj->at(x0_)"+extern "C"+ double CasADi__Matrix_double___at(CasADi::Matrix< double >* obj, int x0);+double CasADi__Matrix_double___at(CasADi::Matrix< double >* obj, int x0){+ int x0_ = Marshaling<int,int>::marshal(x0);++ return obj->at(x0_);+}+++// ================== Normal method: "elem" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::elem"+// cWrapperName: "CasADi__Matrix_double___elem"+// protoArgs: "(CasADi::Matrix< double >* obj, int x0, int x1)"+// args: "(x0_, x1_)"+// rettype: Val (NonVec CDouble)+// cWrapperRetType: "double"+// proto: "double CasADi__Matrix_double___elem(CasADi::Matrix< double >* obj, int x0, int x1)"+// call: "obj->elem(x0_, x1_)"+extern "C"+ double CasADi__Matrix_double___elem(CasADi::Matrix< double >* obj, int x0, int x1);+double CasADi__Matrix_double___elem(CasADi::Matrix< double >* obj, int x0, int x1){+ int x0_ = Marshaling<int,int>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);++ return obj->elem(x0_, x1_);+}+++// ================== Normal method: "elem'" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::elem'"+// cWrapperName: "CasADi__Matrix_double___elem_TIC"+// protoArgs: "(CasADi::Matrix< double >* obj, int x0)"+// args: "(x0_)"+// rettype: Val (NonVec CDouble)+// cWrapperRetType: "double"+// proto: "double CasADi__Matrix_double___elem_TIC(CasADi::Matrix< double >* obj, int x0)"+// call: "obj->elem(x0_)"+extern "C"+ double CasADi__Matrix_double___elem_TIC(CasADi::Matrix< double >* obj, int x0);+double CasADi__Matrix_double___elem_TIC(CasADi::Matrix< double >* obj, int x0){+ int x0_ = Marshaling<int,int>::marshal(x0);++ return obj->elem(x0_);+}+++// ================== Normal method: "hasNZ" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::hasNZ"+// cWrapperName: "CasADi__Matrix_double___hasNZ"+// protoArgs: "(CasADi::Matrix< double >* obj, int x0, int x1)"+// args: "(x0_, x1_)"+// rettype: Val (NonVec CBool)+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__Matrix_double___hasNZ(CasADi::Matrix< double >* obj, int x0, int x1)"+// call: "obj->hasNZ(x0_, x1_)"+extern "C"+ bool* CasADi__Matrix_double___hasNZ(CasADi::Matrix< double >* obj, int x0, int x1);+bool* CasADi__Matrix_double___hasNZ(CasADi::Matrix< double >* obj, int x0, int x1){+ int x0_ = Marshaling<int,int>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);++ return new bool( obj->hasNZ(x0_, x1_) );+}+++// ================== Normal method: "__nonzero__" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::__nonzero__"+// cWrapperName: "CasADi__Matrix_double_____nonzero__"+// protoArgs: "(CasADi::Matrix< double >* obj)"+// args: "()"+// rettype: Val (NonVec CBool)+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__Matrix_double_____nonzero__(CasADi::Matrix< double >* obj)"+// call: "obj->__nonzero__()"+extern "C"+ bool* CasADi__Matrix_double_____nonzero__(CasADi::Matrix< double >* obj);+bool* CasADi__Matrix_double_____nonzero__(CasADi::Matrix< double >* obj){++ return new bool( obj->__nonzero__() );+}+++// ================== Normal method: "append" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::append"+// cWrapperName: "CasADi__Matrix_double___append"+// protoArgs: "(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"+// args: "(x0_)"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__Matrix_double___append(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"+// call: "obj->append(x0_)"+extern "C"+ void CasADi__Matrix_double___append(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0);+void CasADi__Matrix_double___append(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);++ return obj->append(x0_);+}+++// ================== Normal method: "operator +" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::operator +"+// cWrapperName: "CasADi__Matrix_double___operator_plus"+// protoArgs: "(CasADi::Matrix< double >* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass DMatrix))+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___operator_plus(CasADi::Matrix< double >* obj)"+// call: "obj->operator +()"+extern "C"+ CasADi::Matrix< double >* CasADi__Matrix_double___operator_plus(CasADi::Matrix< double >* obj);+CasADi::Matrix< double >* CasADi__Matrix_double___operator_plus(CasADi::Matrix< double >* obj){++ return new CasADi::Matrix< double >( obj->operator +() );+}+++// ================== Normal method: "operator -" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::operator -"+// cWrapperName: "CasADi__Matrix_double___operator_minus"+// protoArgs: "(CasADi::Matrix< double >* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass DMatrix))+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___operator_minus(CasADi::Matrix< double >* obj)"+// call: "obj->operator -()"+extern "C"+ CasADi::Matrix< double >* CasADi__Matrix_double___operator_minus(CasADi::Matrix< double >* obj);+CasADi::Matrix< double >* CasADi__Matrix_double___operator_minus(CasADi::Matrix< double >* obj){++ return new CasADi::Matrix< double >( obj->operator -() );+}+++// ================== Static method: "binary" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::binary"+// cWrapperName: "CasADi__Matrix_double___binary"+// protoArgs: "(int x0, CasADi::Matrix< double >* x1, CasADi::Matrix< double >* x2)"+// args: "(x0_, x1_, x2_)"+// rettype: Val (NonVec (CasadiClass DMatrix))+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___binary(int x0, CasADi::Matrix< double >* x1, CasADi::Matrix< double >* x2)"+// call: "CasADi::Matrix< double >::binary(x0_, x1_, x2_)"+extern "C"+ CasADi::Matrix< double >* CasADi__Matrix_double___binary(int x0, CasADi::Matrix< double >* x1, CasADi::Matrix< double >* x2);+CasADi::Matrix< double >* CasADi__Matrix_double___binary(int x0, CasADi::Matrix< double >* x1, CasADi::Matrix< double >* x2){+ int x0_ = Marshaling<int,int>::marshal(x0);+ CasADi::Matrix< double > x1_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x1);+ CasADi::Matrix< double > x2_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x2);++ return new CasADi::Matrix< double >( CasADi::Matrix< double >::binary(x0_, x1_, x2_) );+}+++// ================== Static method: "unary" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::unary"+// cWrapperName: "CasADi__Matrix_double___unary"+// protoArgs: "(int x0, CasADi::Matrix< double >* x1)"+// args: "(x0_, x1_)"+// rettype: Val (NonVec (CasadiClass DMatrix))+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___unary(int x0, CasADi::Matrix< double >* x1)"+// call: "CasADi::Matrix< double >::unary(x0_, x1_)"+extern "C"+ CasADi::Matrix< double >* CasADi__Matrix_double___unary(int x0, CasADi::Matrix< double >* x1);+CasADi::Matrix< double >* CasADi__Matrix_double___unary(int x0, CasADi::Matrix< double >* x1){+ int x0_ = Marshaling<int,int>::marshal(x0);+ CasADi::Matrix< double > x1_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x1);++ return new CasADi::Matrix< double >( CasADi::Matrix< double >::unary(x0_, x1_) );+}+++// ================== Static method: "scalar_matrix" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::scalar_matrix"+// cWrapperName: "CasADi__Matrix_double___scalar_matrix"+// protoArgs: "(int x0, CasADi::Matrix< double >* x1, CasADi::Matrix< double >* x2)"+// args: "(x0_, x1_, x2_)"+// rettype: Val (NonVec (CasadiClass DMatrix))+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___scalar_matrix(int x0, CasADi::Matrix< double >* x1, CasADi::Matrix< double >* x2)"+// call: "CasADi::Matrix< double >::scalar_matrix(x0_, x1_, x2_)"+extern "C"+ CasADi::Matrix< double >* CasADi__Matrix_double___scalar_matrix(int x0, CasADi::Matrix< double >* x1, CasADi::Matrix< double >* x2);+CasADi::Matrix< double >* CasADi__Matrix_double___scalar_matrix(int x0, CasADi::Matrix< double >* x1, CasADi::Matrix< double >* x2){+ int x0_ = Marshaling<int,int>::marshal(x0);+ CasADi::Matrix< double > x1_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x1);+ CasADi::Matrix< double > x2_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x2);++ return new CasADi::Matrix< double >( CasADi::Matrix< double >::scalar_matrix(x0_, x1_, x2_) );+}+++// ================== Static method: "matrix_scalar" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::matrix_scalar"+// cWrapperName: "CasADi__Matrix_double___matrix_scalar"+// protoArgs: "(int x0, CasADi::Matrix< double >* x1, CasADi::Matrix< double >* x2)"+// args: "(x0_, x1_, x2_)"+// rettype: Val (NonVec (CasadiClass DMatrix))+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___matrix_scalar(int x0, CasADi::Matrix< double >* x1, CasADi::Matrix< double >* x2)"+// call: "CasADi::Matrix< double >::matrix_scalar(x0_, x1_, x2_)"+extern "C"+ CasADi::Matrix< double >* CasADi__Matrix_double___matrix_scalar(int x0, CasADi::Matrix< double >* x1, CasADi::Matrix< double >* x2);+CasADi::Matrix< double >* CasADi__Matrix_double___matrix_scalar(int x0, CasADi::Matrix< double >* x1, CasADi::Matrix< double >* x2){+ int x0_ = Marshaling<int,int>::marshal(x0);+ CasADi::Matrix< double > x1_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x1);+ CasADi::Matrix< double > x2_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x2);++ return new CasADi::Matrix< double >( CasADi::Matrix< double >::matrix_scalar(x0_, x1_, x2_) );+}+++// ================== Static method: "matrix_matrix" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::matrix_matrix"+// cWrapperName: "CasADi__Matrix_double___matrix_matrix"+// protoArgs: "(int x0, CasADi::Matrix< double >* x1, CasADi::Matrix< double >* x2)"+// args: "(x0_, x1_, x2_)"+// rettype: Val (NonVec (CasadiClass DMatrix))+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___matrix_matrix(int x0, CasADi::Matrix< double >* x1, CasADi::Matrix< double >* x2)"+// call: "CasADi::Matrix< double >::matrix_matrix(x0_, x1_, x2_)"+extern "C"+ CasADi::Matrix< double >* CasADi__Matrix_double___matrix_matrix(int x0, CasADi::Matrix< double >* x1, CasADi::Matrix< double >* x2);+CasADi::Matrix< double >* CasADi__Matrix_double___matrix_matrix(int x0, CasADi::Matrix< double >* x1, CasADi::Matrix< double >* x2){+ int x0_ = Marshaling<int,int>::marshal(x0);+ CasADi::Matrix< double > x1_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x1);+ CasADi::Matrix< double > x2_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x2);++ return new CasADi::Matrix< double >( CasADi::Matrix< double >::matrix_matrix(x0_, x1_, x2_) );+}+++// ================== Normal method: "__add__" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::__add__"+// cWrapperName: "CasADi__Matrix_double_____add__"+// protoArgs: "(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass DMatrix))+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__Matrix_double_____add__(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"+// call: "obj->__add__(x0_)"+extern "C"+ CasADi::Matrix< double >* CasADi__Matrix_double_____add__(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0);+CasADi::Matrix< double >* CasADi__Matrix_double_____add__(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);++ return new CasADi::Matrix< double >( obj->__add__(x0_) );+}+++// ================== Normal method: "__sub__" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::__sub__"+// cWrapperName: "CasADi__Matrix_double_____sub__"+// protoArgs: "(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass DMatrix))+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__Matrix_double_____sub__(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"+// call: "obj->__sub__(x0_)"+extern "C"+ CasADi::Matrix< double >* CasADi__Matrix_double_____sub__(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0);+CasADi::Matrix< double >* CasADi__Matrix_double_____sub__(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);++ return new CasADi::Matrix< double >( obj->__sub__(x0_) );+}+++// ================== Normal method: "__mul__" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::__mul__"+// cWrapperName: "CasADi__Matrix_double_____mul__"+// protoArgs: "(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass DMatrix))+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__Matrix_double_____mul__(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"+// call: "obj->__mul__(x0_)"+extern "C"+ CasADi::Matrix< double >* CasADi__Matrix_double_____mul__(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0);+CasADi::Matrix< double >* CasADi__Matrix_double_____mul__(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);++ return new CasADi::Matrix< double >( obj->__mul__(x0_) );+}+++// ================== Normal method: "__div__" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::__div__"+// cWrapperName: "CasADi__Matrix_double_____div__"+// protoArgs: "(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass DMatrix))+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__Matrix_double_____div__(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"+// call: "obj->__div__(x0_)"+extern "C"+ CasADi::Matrix< double >* CasADi__Matrix_double_____div__(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0);+CasADi::Matrix< double >* CasADi__Matrix_double_____div__(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);++ return new CasADi::Matrix< double >( obj->__div__(x0_) );+}+++// ================== Normal method: "__lt__" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::__lt__"+// cWrapperName: "CasADi__Matrix_double_____lt__"+// protoArgs: "(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass DMatrix))+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__Matrix_double_____lt__(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"+// call: "obj->__lt__(x0_)"+extern "C"+ CasADi::Matrix< double >* CasADi__Matrix_double_____lt__(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0);+CasADi::Matrix< double >* CasADi__Matrix_double_____lt__(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);++ return new CasADi::Matrix< double >( obj->__lt__(x0_) );+}+++// ================== Normal method: "__le__" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::__le__"+// cWrapperName: "CasADi__Matrix_double_____le__"+// protoArgs: "(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass DMatrix))+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__Matrix_double_____le__(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"+// call: "obj->__le__(x0_)"+extern "C"+ CasADi::Matrix< double >* CasADi__Matrix_double_____le__(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0);+CasADi::Matrix< double >* CasADi__Matrix_double_____le__(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);++ return new CasADi::Matrix< double >( obj->__le__(x0_) );+}+++// ================== Normal method: "__eq__" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::__eq__"+// cWrapperName: "CasADi__Matrix_double_____eq__"+// protoArgs: "(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass DMatrix))+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__Matrix_double_____eq__(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"+// call: "obj->__eq__(x0_)"+extern "C"+ CasADi::Matrix< double >* CasADi__Matrix_double_____eq__(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0);+CasADi::Matrix< double >* CasADi__Matrix_double_____eq__(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);++ return new CasADi::Matrix< double >( obj->__eq__(x0_) );+}+++// ================== Normal method: "__ne__" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::__ne__"+// cWrapperName: "CasADi__Matrix_double_____ne__"+// protoArgs: "(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass DMatrix))+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__Matrix_double_____ne__(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"+// call: "obj->__ne__(x0_)"+extern "C"+ CasADi::Matrix< double >* CasADi__Matrix_double_____ne__(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0);+CasADi::Matrix< double >* CasADi__Matrix_double_____ne__(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);++ return new CasADi::Matrix< double >( obj->__ne__(x0_) );+}+++// ================== Normal method: "__truediv__" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::__truediv__"+// cWrapperName: "CasADi__Matrix_double_____truediv__"+// protoArgs: "(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass DMatrix))+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__Matrix_double_____truediv__(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"+// call: "obj->__truediv__(x0_)"+extern "C"+ CasADi::Matrix< double >* CasADi__Matrix_double_____truediv__(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0);+CasADi::Matrix< double >* CasADi__Matrix_double_____truediv__(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);++ return new CasADi::Matrix< double >( obj->__truediv__(x0_) );+}+++// ================== Normal method: "__pow__" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::__pow__"+// cWrapperName: "CasADi__Matrix_double_____pow__"+// protoArgs: "(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass DMatrix))+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__Matrix_double_____pow__(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"+// call: "obj->__pow__(x0_)"+extern "C"+ CasADi::Matrix< double >* CasADi__Matrix_double_____pow__(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0);+CasADi::Matrix< double >* CasADi__Matrix_double_____pow__(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);++ return new CasADi::Matrix< double >( obj->__pow__(x0_) );+}+++// ================== Normal method: "__constpow__" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::__constpow__"+// cWrapperName: "CasADi__Matrix_double_____constpow__"+// protoArgs: "(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass DMatrix))+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__Matrix_double_____constpow__(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"+// call: "obj->__constpow__(x0_)"+extern "C"+ CasADi::Matrix< double >* CasADi__Matrix_double_____constpow__(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0);+CasADi::Matrix< double >* CasADi__Matrix_double_____constpow__(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);++ return new CasADi::Matrix< double >( obj->__constpow__(x0_) );+}+++// ================== Normal method: "__mpower__" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::__mpower__"+// cWrapperName: "CasADi__Matrix_double_____mpower__"+// protoArgs: "(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass DMatrix))+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__Matrix_double_____mpower__(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"+// call: "obj->__mpower__(x0_)"+extern "C"+ CasADi::Matrix< double >* CasADi__Matrix_double_____mpower__(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0);+CasADi::Matrix< double >* CasADi__Matrix_double_____mpower__(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);++ return new CasADi::Matrix< double >( obj->__mpower__(x0_) );+}+++// ================== Normal method: "__mrdivide__" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::__mrdivide__"+// cWrapperName: "CasADi__Matrix_double_____mrdivide__"+// protoArgs: "(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass DMatrix))+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__Matrix_double_____mrdivide__(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"+// call: "obj->__mrdivide__(x0_)"+extern "C"+ CasADi::Matrix< double >* CasADi__Matrix_double_____mrdivide__(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0);+CasADi::Matrix< double >* CasADi__Matrix_double_____mrdivide__(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);++ return new CasADi::Matrix< double >( obj->__mrdivide__(x0_) );+}+++// ================== Normal method: "mul_full" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::mul_full"+// cWrapperName: "CasADi__Matrix_double___mul_full"+// protoArgs: "(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0, CasADi::CRSSparsity* x1)"+// args: "(x0_, x1_)"+// rettype: Val (NonVec (CasadiClass DMatrix))+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___mul_full(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0, CasADi::CRSSparsity* x1)"+// call: "obj->mul_full(x0_, x1_)"+extern "C"+ CasADi::Matrix< double >* CasADi__Matrix_double___mul_full(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0, CasADi::CRSSparsity* x1);+CasADi::Matrix< double >* CasADi__Matrix_double___mul_full(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0, CasADi::CRSSparsity* x1){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);+ CasADi::CRSSparsity x1_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x1);++ return new CasADi::Matrix< double >( obj->mul_full(x0_, x1_) );+}+++// ================== Normal method: "mul_full'" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::mul_full'"+// cWrapperName: "CasADi__Matrix_double___mul_full_TIC"+// protoArgs: "(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass DMatrix))+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___mul_full_TIC(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"+// call: "obj->mul_full(x0_)"+extern "C"+ CasADi::Matrix< double >* CasADi__Matrix_double___mul_full_TIC(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0);+CasADi::Matrix< double >* CasADi__Matrix_double___mul_full_TIC(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);++ return new CasADi::Matrix< double >( obj->mul_full(x0_) );+}+++// ================== Normal method: "mul" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::mul"+// cWrapperName: "CasADi__Matrix_double___mul"+// protoArgs: "(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0, CasADi::CRSSparsity* x1)"+// args: "(x0_, x1_)"+// rettype: Val (NonVec (CasadiClass DMatrix))+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___mul(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0, CasADi::CRSSparsity* x1)"+// call: "obj->mul(x0_, x1_)"+extern "C"+ CasADi::Matrix< double >* CasADi__Matrix_double___mul(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0, CasADi::CRSSparsity* x1);+CasADi::Matrix< double >* CasADi__Matrix_double___mul(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0, CasADi::CRSSparsity* x1){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);+ CasADi::CRSSparsity x1_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x1);++ return new CasADi::Matrix< double >( obj->mul(x0_, x1_) );+}+++// ================== Normal method: "mul'" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::mul'"+// cWrapperName: "CasADi__Matrix_double___mul_TIC"+// protoArgs: "(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass DMatrix))+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___mul_TIC(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"+// call: "obj->mul(x0_)"+extern "C"+ CasADi::Matrix< double >* CasADi__Matrix_double___mul_TIC(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0);+CasADi::Matrix< double >* CasADi__Matrix_double___mul_TIC(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);++ return new CasADi::Matrix< double >( obj->mul(x0_) );+}+++// ================== Static method: "mul_no_alloc_nn" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::mul_no_alloc_nn"+// cWrapperName: "CasADi__Matrix_double___mul_no_alloc_nn"+// protoArgs: "(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1, CasADi::Matrix< double >* x2)"+// args: "(x0_, x1_, x2_)"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__Matrix_double___mul_no_alloc_nn(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1, CasADi::Matrix< double >* x2)"+// call: "CasADi::Matrix< double >::mul_no_alloc_nn(x0_, x1_, x2_)"+extern "C"+ void CasADi__Matrix_double___mul_no_alloc_nn(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1, CasADi::Matrix< double >* x2);+void CasADi__Matrix_double___mul_no_alloc_nn(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1, CasADi::Matrix< double >* x2){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);+ CasADi::Matrix< double > x1_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x1);+ CasADi::Matrix< double > x2_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x2);++ return CasADi::Matrix< double >::mul_no_alloc_nn(x0_, x1_, x2_);+}+++// ================== Static method: "mul_no_alloc_nt" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::mul_no_alloc_nt"+// cWrapperName: "CasADi__Matrix_double___mul_no_alloc_nt"+// protoArgs: "(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1, CasADi::Matrix< double >* x2)"+// args: "(x0_, x1_, x2_)"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__Matrix_double___mul_no_alloc_nt(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1, CasADi::Matrix< double >* x2)"+// call: "CasADi::Matrix< double >::mul_no_alloc_nt(x0_, x1_, x2_)"+extern "C"+ void CasADi__Matrix_double___mul_no_alloc_nt(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1, CasADi::Matrix< double >* x2);+void CasADi__Matrix_double___mul_no_alloc_nt(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1, CasADi::Matrix< double >* x2){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);+ CasADi::Matrix< double > x1_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x1);+ CasADi::Matrix< double > x2_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x2);++ return CasADi::Matrix< double >::mul_no_alloc_nt(x0_, x1_, x2_);+}+++// ================== Static method: "mul_no_alloc_tn" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::mul_no_alloc_tn"+// cWrapperName: "CasADi__Matrix_double___mul_no_alloc_tn"+// protoArgs: "(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1, CasADi::Matrix< double >* x2)"+// args: "(x0_, x1_, x2_)"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__Matrix_double___mul_no_alloc_tn(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1, CasADi::Matrix< double >* x2)"+// call: "CasADi::Matrix< double >::mul_no_alloc_tn(x0_, x1_, x2_)"+extern "C"+ void CasADi__Matrix_double___mul_no_alloc_tn(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1, CasADi::Matrix< double >* x2);+void CasADi__Matrix_double___mul_no_alloc_tn(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1, CasADi::Matrix< double >* x2){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);+ CasADi::Matrix< double > x1_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x1);+ CasADi::Matrix< double > x2_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x2);++ return CasADi::Matrix< double >::mul_no_alloc_tn(x0_, x1_, x2_);+}+++// ================== Static method: "mul_no_alloc_nn'" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::mul_no_alloc_nn'"+// cWrapperName: "CasADi__Matrix_double___mul_no_alloc_nn_TIC"+// protoArgs: "(CasADi::Matrix< double >* x0, std::vector<double > * x1, std::vector<double >* x2)"+// args: "(x0_, x1_, x2_)"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__Matrix_double___mul_no_alloc_nn_TIC(CasADi::Matrix< double >* x0, std::vector<double > * x1, std::vector<double >* x2)"+// call: "CasADi::Matrix< double >::mul_no_alloc_nn(x0_, x1_, x2_)"+extern "C"+ void CasADi__Matrix_double___mul_no_alloc_nn_TIC(CasADi::Matrix< double >* x0, std::vector<double > * x1, std::vector<double >* x2);+void CasADi__Matrix_double___mul_no_alloc_nn_TIC(CasADi::Matrix< double >* x0, std::vector<double > * x1, std::vector<double >* x2){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);+ std::vector<double > x1_ = Marshaling<std::vector<double >,std::vector<double > *>::marshal(x1);+ std::vector<double > x2_ = Marshaling<std::vector<double >,std::vector<double >*>::marshal(x2);++ return CasADi::Matrix< double >::mul_no_alloc_nn(x0_, x1_, x2_);+}+++// ================== Static method: "mul_no_alloc_tn'" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::mul_no_alloc_tn'"+// cWrapperName: "CasADi__Matrix_double___mul_no_alloc_tn_TIC"+// protoArgs: "(CasADi::Matrix< double >* x0, std::vector<double > * x1, std::vector<double >* x2)"+// args: "(x0_, x1_, x2_)"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__Matrix_double___mul_no_alloc_tn_TIC(CasADi::Matrix< double >* x0, std::vector<double > * x1, std::vector<double >* x2)"+// call: "CasADi::Matrix< double >::mul_no_alloc_tn(x0_, x1_, x2_)"+extern "C"+ void CasADi__Matrix_double___mul_no_alloc_tn_TIC(CasADi::Matrix< double >* x0, std::vector<double > * x1, std::vector<double >* x2);+void CasADi__Matrix_double___mul_no_alloc_tn_TIC(CasADi::Matrix< double >* x0, std::vector<double > * x1, std::vector<double >* x2){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);+ std::vector<double > x1_ = Marshaling<std::vector<double >,std::vector<double > *>::marshal(x1);+ std::vector<double > x2_ = Marshaling<std::vector<double >,std::vector<double >*>::marshal(x2);++ return CasADi::Matrix< double >::mul_no_alloc_tn(x0_, x1_, x2_);+}+++// ================== Static method: "quad_form" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::quad_form"+// cWrapperName: "CasADi__Matrix_double___quad_form"+// protoArgs: "(CasADi::Matrix< double >* x0, std::vector<double > * x1)"+// args: "(x0_, x1_)"+// rettype: Val (NonVec CDouble)+// cWrapperRetType: "double"+// proto: "double CasADi__Matrix_double___quad_form(CasADi::Matrix< double >* x0, std::vector<double > * x1)"+// call: "CasADi::Matrix< double >::quad_form(x0_, x1_)"+extern "C"+ double CasADi__Matrix_double___quad_form(CasADi::Matrix< double >* x0, std::vector<double > * x1);+double CasADi__Matrix_double___quad_form(CasADi::Matrix< double >* x0, std::vector<double > * x1){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);+ std::vector<double > x1_ = Marshaling<std::vector<double >,std::vector<double > *>::marshal(x1);++ return CasADi::Matrix< double >::quad_form(x0_, x1_);+}+++// ================== Normal method: "trans" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::trans"+// cWrapperName: "CasADi__Matrix_double___trans"+// protoArgs: "(CasADi::Matrix< double >* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass DMatrix))+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___trans(CasADi::Matrix< double >* obj)"+// call: "obj->trans()"+extern "C"+ CasADi::Matrix< double >* CasADi__Matrix_double___trans(CasADi::Matrix< double >* obj);+CasADi::Matrix< double >* CasADi__Matrix_double___trans(CasADi::Matrix< double >* obj){++ return new CasADi::Matrix< double >( obj->trans() );+}+++// ================== Normal method: "sin" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::sin"+// cWrapperName: "CasADi__Matrix_double___sin"+// protoArgs: "(CasADi::Matrix< double >* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass DMatrix))+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___sin(CasADi::Matrix< double >* obj)"+// call: "obj->sin()"+extern "C"+ CasADi::Matrix< double >* CasADi__Matrix_double___sin(CasADi::Matrix< double >* obj);+CasADi::Matrix< double >* CasADi__Matrix_double___sin(CasADi::Matrix< double >* obj){++ return new CasADi::Matrix< double >( obj->sin() );+}+++// ================== Normal method: "cos" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::cos"+// cWrapperName: "CasADi__Matrix_double___cos"+// protoArgs: "(CasADi::Matrix< double >* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass DMatrix))+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___cos(CasADi::Matrix< double >* obj)"+// call: "obj->cos()"+extern "C"+ CasADi::Matrix< double >* CasADi__Matrix_double___cos(CasADi::Matrix< double >* obj);+CasADi::Matrix< double >* CasADi__Matrix_double___cos(CasADi::Matrix< double >* obj){++ return new CasADi::Matrix< double >( obj->cos() );+}+++// ================== Normal method: "tan" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::tan"+// cWrapperName: "CasADi__Matrix_double___tan"+// protoArgs: "(CasADi::Matrix< double >* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass DMatrix))+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___tan(CasADi::Matrix< double >* obj)"+// call: "obj->tan()"+extern "C"+ CasADi::Matrix< double >* CasADi__Matrix_double___tan(CasADi::Matrix< double >* obj);+CasADi::Matrix< double >* CasADi__Matrix_double___tan(CasADi::Matrix< double >* obj){++ return new CasADi::Matrix< double >( obj->tan() );+}+++// ================== Normal method: "arcsin" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::arcsin"+// cWrapperName: "CasADi__Matrix_double___arcsin"+// protoArgs: "(CasADi::Matrix< double >* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass DMatrix))+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___arcsin(CasADi::Matrix< double >* obj)"+// call: "obj->arcsin()"+extern "C"+ CasADi::Matrix< double >* CasADi__Matrix_double___arcsin(CasADi::Matrix< double >* obj);+CasADi::Matrix< double >* CasADi__Matrix_double___arcsin(CasADi::Matrix< double >* obj){++ return new CasADi::Matrix< double >( obj->arcsin() );+}+++// ================== Normal method: "arccos" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::arccos"+// cWrapperName: "CasADi__Matrix_double___arccos"+// protoArgs: "(CasADi::Matrix< double >* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass DMatrix))+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___arccos(CasADi::Matrix< double >* obj)"+// call: "obj->arccos()"+extern "C"+ CasADi::Matrix< double >* CasADi__Matrix_double___arccos(CasADi::Matrix< double >* obj);+CasADi::Matrix< double >* CasADi__Matrix_double___arccos(CasADi::Matrix< double >* obj){++ return new CasADi::Matrix< double >( obj->arccos() );+}+++// ================== Normal method: "arctan" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::arctan"+// cWrapperName: "CasADi__Matrix_double___arctan"+// protoArgs: "(CasADi::Matrix< double >* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass DMatrix))+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___arctan(CasADi::Matrix< double >* obj)"+// call: "obj->arctan()"+extern "C"+ CasADi::Matrix< double >* CasADi__Matrix_double___arctan(CasADi::Matrix< double >* obj);+CasADi::Matrix< double >* CasADi__Matrix_double___arctan(CasADi::Matrix< double >* obj){++ return new CasADi::Matrix< double >( obj->arctan() );+}+++// ================== Normal method: "exp" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::exp"+// cWrapperName: "CasADi__Matrix_double___exp"+// protoArgs: "(CasADi::Matrix< double >* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass DMatrix))+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___exp(CasADi::Matrix< double >* obj)"+// call: "obj->exp()"+extern "C"+ CasADi::Matrix< double >* CasADi__Matrix_double___exp(CasADi::Matrix< double >* obj);+CasADi::Matrix< double >* CasADi__Matrix_double___exp(CasADi::Matrix< double >* obj){++ return new CasADi::Matrix< double >( obj->exp() );+}+++// ================== Normal method: "log" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::log"+// cWrapperName: "CasADi__Matrix_double___log"+// protoArgs: "(CasADi::Matrix< double >* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass DMatrix))+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___log(CasADi::Matrix< double >* obj)"+// call: "obj->log()"+extern "C"+ CasADi::Matrix< double >* CasADi__Matrix_double___log(CasADi::Matrix< double >* obj);+CasADi::Matrix< double >* CasADi__Matrix_double___log(CasADi::Matrix< double >* obj){++ return new CasADi::Matrix< double >( obj->log() );+}+++// ================== Normal method: "sqrt" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::sqrt"+// cWrapperName: "CasADi__Matrix_double___sqrt"+// protoArgs: "(CasADi::Matrix< double >* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass DMatrix))+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___sqrt(CasADi::Matrix< double >* obj)"+// call: "obj->sqrt()"+extern "C"+ CasADi::Matrix< double >* CasADi__Matrix_double___sqrt(CasADi::Matrix< double >* obj);+CasADi::Matrix< double >* CasADi__Matrix_double___sqrt(CasADi::Matrix< double >* obj){++ return new CasADi::Matrix< double >( obj->sqrt() );+}+++// ================== Normal method: "floor" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::floor"+// cWrapperName: "CasADi__Matrix_double___floor"+// protoArgs: "(CasADi::Matrix< double >* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass DMatrix))+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___floor(CasADi::Matrix< double >* obj)"+// call: "obj->floor()"+extern "C"+ CasADi::Matrix< double >* CasADi__Matrix_double___floor(CasADi::Matrix< double >* obj);+CasADi::Matrix< double >* CasADi__Matrix_double___floor(CasADi::Matrix< double >* obj){++ return new CasADi::Matrix< double >( obj->floor() );+}+++// ================== Normal method: "ceil" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::ceil"+// cWrapperName: "CasADi__Matrix_double___ceil"+// protoArgs: "(CasADi::Matrix< double >* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass DMatrix))+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___ceil(CasADi::Matrix< double >* obj)"+// call: "obj->ceil()"+extern "C"+ CasADi::Matrix< double >* CasADi__Matrix_double___ceil(CasADi::Matrix< double >* obj);+CasADi::Matrix< double >* CasADi__Matrix_double___ceil(CasADi::Matrix< double >* obj){++ return new CasADi::Matrix< double >( obj->ceil() );+}+++// ================== Normal method: "fabs" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::fabs"+// cWrapperName: "CasADi__Matrix_double___fabs"+// protoArgs: "(CasADi::Matrix< double >* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass DMatrix))+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___fabs(CasADi::Matrix< double >* obj)"+// call: "obj->fabs()"+extern "C"+ CasADi::Matrix< double >* CasADi__Matrix_double___fabs(CasADi::Matrix< double >* obj);+CasADi::Matrix< double >* CasADi__Matrix_double___fabs(CasADi::Matrix< double >* obj){++ return new CasADi::Matrix< double >( obj->fabs() );+}+++// ================== Normal method: "sign" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::sign"+// cWrapperName: "CasADi__Matrix_double___sign"+// protoArgs: "(CasADi::Matrix< double >* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass DMatrix))+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___sign(CasADi::Matrix< double >* obj)"+// call: "obj->sign()"+extern "C"+ CasADi::Matrix< double >* CasADi__Matrix_double___sign(CasADi::Matrix< double >* obj);+CasADi::Matrix< double >* CasADi__Matrix_double___sign(CasADi::Matrix< double >* obj){++ return new CasADi::Matrix< double >( obj->sign() );+}+++// ================== Normal method: "erfinv" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::erfinv"+// cWrapperName: "CasADi__Matrix_double___erfinv"+// protoArgs: "(CasADi::Matrix< double >* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass DMatrix))+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___erfinv(CasADi::Matrix< double >* obj)"+// call: "obj->erfinv()"+extern "C"+ CasADi::Matrix< double >* CasADi__Matrix_double___erfinv(CasADi::Matrix< double >* obj);+CasADi::Matrix< double >* CasADi__Matrix_double___erfinv(CasADi::Matrix< double >* obj){++ return new CasADi::Matrix< double >( obj->erfinv() );+}+++// ================== Normal method: "fmin" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::fmin"+// cWrapperName: "CasADi__Matrix_double___fmin"+// protoArgs: "(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass DMatrix))+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___fmin(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"+// call: "obj->fmin(x0_)"+extern "C"+ CasADi::Matrix< double >* CasADi__Matrix_double___fmin(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0);+CasADi::Matrix< double >* CasADi__Matrix_double___fmin(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);++ return new CasADi::Matrix< double >( obj->fmin(x0_) );+}+++// ================== Normal method: "fmax" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::fmax"+// cWrapperName: "CasADi__Matrix_double___fmax"+// protoArgs: "(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass DMatrix))+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___fmax(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"+// call: "obj->fmax(x0_)"+extern "C"+ CasADi::Matrix< double >* CasADi__Matrix_double___fmax(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0);+CasADi::Matrix< double >* CasADi__Matrix_double___fmax(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);++ return new CasADi::Matrix< double >( obj->fmax(x0_) );+}+++// ================== Normal method: "erf" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::erf"+// cWrapperName: "CasADi__Matrix_double___erf"+// protoArgs: "(CasADi::Matrix< double >* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass DMatrix))+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___erf(CasADi::Matrix< double >* obj)"+// call: "obj->erf()"+extern "C"+ CasADi::Matrix< double >* CasADi__Matrix_double___erf(CasADi::Matrix< double >* obj);+CasADi::Matrix< double >* CasADi__Matrix_double___erf(CasADi::Matrix< double >* obj){++ return new CasADi::Matrix< double >( obj->erf() );+}+++// ================== Normal method: "sinh" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::sinh"+// cWrapperName: "CasADi__Matrix_double___sinh"+// protoArgs: "(CasADi::Matrix< double >* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass DMatrix))+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___sinh(CasADi::Matrix< double >* obj)"+// call: "obj->sinh()"+extern "C"+ CasADi::Matrix< double >* CasADi__Matrix_double___sinh(CasADi::Matrix< double >* obj);+CasADi::Matrix< double >* CasADi__Matrix_double___sinh(CasADi::Matrix< double >* obj){++ return new CasADi::Matrix< double >( obj->sinh() );+}+++// ================== Normal method: "cosh" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::cosh"+// cWrapperName: "CasADi__Matrix_double___cosh"+// protoArgs: "(CasADi::Matrix< double >* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass DMatrix))+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___cosh(CasADi::Matrix< double >* obj)"+// call: "obj->cosh()"+extern "C"+ CasADi::Matrix< double >* CasADi__Matrix_double___cosh(CasADi::Matrix< double >* obj);+CasADi::Matrix< double >* CasADi__Matrix_double___cosh(CasADi::Matrix< double >* obj){++ return new CasADi::Matrix< double >( obj->cosh() );+}+++// ================== Normal method: "tanh" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::tanh"+// cWrapperName: "CasADi__Matrix_double___tanh"+// protoArgs: "(CasADi::Matrix< double >* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass DMatrix))+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___tanh(CasADi::Matrix< double >* obj)"+// call: "obj->tanh()"+extern "C"+ CasADi::Matrix< double >* CasADi__Matrix_double___tanh(CasADi::Matrix< double >* obj);+CasADi::Matrix< double >* CasADi__Matrix_double___tanh(CasADi::Matrix< double >* obj){++ return new CasADi::Matrix< double >( obj->tanh() );+}+++// ================== Normal method: "arcsinh" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::arcsinh"+// cWrapperName: "CasADi__Matrix_double___arcsinh"+// protoArgs: "(CasADi::Matrix< double >* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass DMatrix))+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___arcsinh(CasADi::Matrix< double >* obj)"+// call: "obj->arcsinh()"+extern "C"+ CasADi::Matrix< double >* CasADi__Matrix_double___arcsinh(CasADi::Matrix< double >* obj);+CasADi::Matrix< double >* CasADi__Matrix_double___arcsinh(CasADi::Matrix< double >* obj){++ return new CasADi::Matrix< double >( obj->arcsinh() );+}+++// ================== Normal method: "arccosh" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::arccosh"+// cWrapperName: "CasADi__Matrix_double___arccosh"+// protoArgs: "(CasADi::Matrix< double >* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass DMatrix))+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___arccosh(CasADi::Matrix< double >* obj)"+// call: "obj->arccosh()"+extern "C"+ CasADi::Matrix< double >* CasADi__Matrix_double___arccosh(CasADi::Matrix< double >* obj);+CasADi::Matrix< double >* CasADi__Matrix_double___arccosh(CasADi::Matrix< double >* obj){++ return new CasADi::Matrix< double >( obj->arccosh() );+}+++// ================== Normal method: "arctanh" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::arctanh"+// cWrapperName: "CasADi__Matrix_double___arctanh"+// protoArgs: "(CasADi::Matrix< double >* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass DMatrix))+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___arctanh(CasADi::Matrix< double >* obj)"+// call: "obj->arctanh()"+extern "C"+ CasADi::Matrix< double >* CasADi__Matrix_double___arctanh(CasADi::Matrix< double >* obj);+CasADi::Matrix< double >* CasADi__Matrix_double___arctanh(CasADi::Matrix< double >* obj){++ return new CasADi::Matrix< double >( obj->arctanh() );+}+++// ================== Normal method: "arctan2" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::arctan2"+// cWrapperName: "CasADi__Matrix_double___arctan2"+// protoArgs: "(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass DMatrix))+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___arctan2(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"+// call: "obj->arctan2(x0_)"+extern "C"+ CasADi::Matrix< double >* CasADi__Matrix_double___arctan2(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0);+CasADi::Matrix< double >* CasADi__Matrix_double___arctan2(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);++ return new CasADi::Matrix< double >( obj->arctan2(x0_) );+}+++// ================== Normal method: "log10" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::log10"+// cWrapperName: "CasADi__Matrix_double___log10"+// protoArgs: "(CasADi::Matrix< double >* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass DMatrix))+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___log10(CasADi::Matrix< double >* obj)"+// call: "obj->log10()"+extern "C"+ CasADi::Matrix< double >* CasADi__Matrix_double___log10(CasADi::Matrix< double >* obj);+CasADi::Matrix< double >* CasADi__Matrix_double___log10(CasADi::Matrix< double >* obj){++ return new CasADi::Matrix< double >( obj->log10() );+}+++// ================== Normal method: "printme" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::printme"+// cWrapperName: "CasADi__Matrix_double___printme"+// protoArgs: "(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass DMatrix))+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___printme(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"+// call: "obj->printme(x0_)"+extern "C"+ CasADi::Matrix< double >* CasADi__Matrix_double___printme(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0);+CasADi::Matrix< double >* CasADi__Matrix_double___printme(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);++ return new CasADi::Matrix< double >( obj->printme(x0_) );+}+++// ================== Normal method: "logic_not" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::logic_not"+// cWrapperName: "CasADi__Matrix_double___logic_not"+// protoArgs: "(CasADi::Matrix< double >* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass DMatrix))+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___logic_not(CasADi::Matrix< double >* obj)"+// call: "obj->logic_not()"+extern "C"+ CasADi::Matrix< double >* CasADi__Matrix_double___logic_not(CasADi::Matrix< double >* obj);+CasADi::Matrix< double >* CasADi__Matrix_double___logic_not(CasADi::Matrix< double >* obj){++ return new CasADi::Matrix< double >( obj->logic_not() );+}+++// ================== Normal method: "logic_and" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::logic_and"+// cWrapperName: "CasADi__Matrix_double___logic_and"+// protoArgs: "(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass DMatrix))+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___logic_and(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"+// call: "obj->logic_and(x0_)"+extern "C"+ CasADi::Matrix< double >* CasADi__Matrix_double___logic_and(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0);+CasADi::Matrix< double >* CasADi__Matrix_double___logic_and(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);++ return new CasADi::Matrix< double >( obj->logic_and(x0_) );+}+++// ================== Normal method: "logic_or" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::logic_or"+// cWrapperName: "CasADi__Matrix_double___logic_or"+// protoArgs: "(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass DMatrix))+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___logic_or(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"+// call: "obj->logic_or(x0_)"+extern "C"+ CasADi::Matrix< double >* CasADi__Matrix_double___logic_or(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0);+CasADi::Matrix< double >* CasADi__Matrix_double___logic_or(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);++ return new CasADi::Matrix< double >( obj->logic_or(x0_) );+}+++// ================== Normal method: "if_else_zero" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::if_else_zero"+// cWrapperName: "CasADi__Matrix_double___if_else_zero"+// protoArgs: "(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass DMatrix))+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___if_else_zero(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"+// call: "obj->if_else_zero(x0_)"+extern "C"+ CasADi::Matrix< double >* CasADi__Matrix_double___if_else_zero(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0);+CasADi::Matrix< double >* CasADi__Matrix_double___if_else_zero(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);++ return new CasADi::Matrix< double >( obj->if_else_zero(x0_) );+}+++// ================== Static method: "className" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::className"+// cWrapperName: "CasADi__Matrix_double___className"+// protoArgs: "()"+// args: "()"+// rettype: Val (NonVec StdString)+// cWrapperRetType: "std::string*"+// proto: "std::string* CasADi__Matrix_double___className()"+// call: "CasADi::Matrix< double >::className()"+extern "C"+ std::string* CasADi__Matrix_double___className();+std::string* CasADi__Matrix_double___className(){++ return new std::string( CasADi::Matrix< double >::className() );+}+++// ================== Normal method: "printScalar'" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::printScalar'"+// cWrapperName: "CasADi__Matrix_double___printScalar_TIC"+// protoArgs: "(CasADi::Matrix< double >* obj)"+// args: "()"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__Matrix_double___printScalar_TIC(CasADi::Matrix< double >* obj)"+// call: "obj->printScalar()"+extern "C"+ void CasADi__Matrix_double___printScalar_TIC(CasADi::Matrix< double >* obj);+void CasADi__Matrix_double___printScalar_TIC(CasADi::Matrix< double >* obj){++ return obj->printScalar();+}+++// ================== Normal method: "printVector'" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::printVector'"+// cWrapperName: "CasADi__Matrix_double___printVector_TIC"+// protoArgs: "(CasADi::Matrix< double >* obj)"+// args: "()"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__Matrix_double___printVector_TIC(CasADi::Matrix< double >* obj)"+// call: "obj->printVector()"+extern "C"+ void CasADi__Matrix_double___printVector_TIC(CasADi::Matrix< double >* obj);+void CasADi__Matrix_double___printVector_TIC(CasADi::Matrix< double >* obj){++ return obj->printVector();+}+++// ================== Normal method: "printMatrix'" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::printMatrix'"+// cWrapperName: "CasADi__Matrix_double___printMatrix_TIC"+// protoArgs: "(CasADi::Matrix< double >* obj)"+// args: "()"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__Matrix_double___printMatrix_TIC(CasADi::Matrix< double >* obj)"+// call: "obj->printMatrix()"+extern "C"+ void CasADi__Matrix_double___printMatrix_TIC(CasADi::Matrix< double >* obj);+void CasADi__Matrix_double___printMatrix_TIC(CasADi::Matrix< double >* obj){++ return obj->printMatrix();+}+++// ================== Normal method: "printSparse'" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::printSparse'"+// cWrapperName: "CasADi__Matrix_double___printSparse_TIC"+// protoArgs: "(CasADi::Matrix< double >* obj)"+// args: "()"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__Matrix_double___printSparse_TIC(CasADi::Matrix< double >* obj)"+// call: "obj->printSparse()"+extern "C"+ void CasADi__Matrix_double___printSparse_TIC(CasADi::Matrix< double >* obj);+void CasADi__Matrix_double___printSparse_TIC(CasADi::Matrix< double >* obj){++ return obj->printSparse();+}+++// ================== Normal method: "printDense'" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::printDense'"+// cWrapperName: "CasADi__Matrix_double___printDense_TIC"+// protoArgs: "(CasADi::Matrix< double >* obj)"+// args: "()"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__Matrix_double___printDense_TIC(CasADi::Matrix< double >* obj)"+// call: "obj->printDense()"+extern "C"+ void CasADi__Matrix_double___printDense_TIC(CasADi::Matrix< double >* obj);+void CasADi__Matrix_double___printDense_TIC(CasADi::Matrix< double >* obj){++ return obj->printDense();+}+++// ================== Normal method: "col" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::col"+// cWrapperName: "CasADi__Matrix_double___col"+// protoArgs: "(CasADi::Matrix< double >* obj, int x0)"+// args: "(x0_)"+// rettype: Val (NonVec CInt)+// cWrapperRetType: "int"+// proto: "int CasADi__Matrix_double___col(CasADi::Matrix< double >* obj, int x0)"+// call: "obj->col(x0_)"+extern "C"+ int CasADi__Matrix_double___col(CasADi::Matrix< double >* obj, int x0);+int CasADi__Matrix_double___col(CasADi::Matrix< double >* obj, int x0){+ int x0_ = Marshaling<int,int>::marshal(x0);++ return obj->col(x0_);+}+++// ================== Normal method: "rowind" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::rowind"+// cWrapperName: "CasADi__Matrix_double___rowind"+// protoArgs: "(CasADi::Matrix< double >* obj, int x0)"+// args: "(x0_)"+// rettype: Val (NonVec CInt)+// cWrapperRetType: "int"+// proto: "int CasADi__Matrix_double___rowind(CasADi::Matrix< double >* obj, int x0)"+// call: "obj->rowind(x0_)"+extern "C"+ int CasADi__Matrix_double___rowind(CasADi::Matrix< double >* obj, int x0);+int CasADi__Matrix_double___rowind(CasADi::Matrix< double >* obj, int x0){+ int x0_ = Marshaling<int,int>::marshal(x0);++ return obj->rowind(x0_);+}+++// ================== Normal method: "clear" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::clear"+// cWrapperName: "CasADi__Matrix_double___clear"+// protoArgs: "(CasADi::Matrix< double >* obj)"+// args: "()"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__Matrix_double___clear(CasADi::Matrix< double >* obj)"+// call: "obj->clear()"+extern "C"+ void CasADi__Matrix_double___clear(CasADi::Matrix< double >* obj);+void CasADi__Matrix_double___clear(CasADi::Matrix< double >* obj){++ return obj->clear();+}+++// ================== Normal method: "resize" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::resize"+// cWrapperName: "CasADi__Matrix_double___resize"+// protoArgs: "(CasADi::Matrix< double >* obj, int x0, int x1)"+// args: "(x0_, x1_)"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__Matrix_double___resize(CasADi::Matrix< double >* obj, int x0, int x1)"+// call: "obj->resize(x0_, x1_)"+extern "C"+ void CasADi__Matrix_double___resize(CasADi::Matrix< double >* obj, int x0, int x1);+void CasADi__Matrix_double___resize(CasADi::Matrix< double >* obj, int x0, int x1){+ int x0_ = Marshaling<int,int>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);++ return obj->resize(x0_, x1_);+}+++// ================== Normal method: "reserve" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::reserve"+// cWrapperName: "CasADi__Matrix_double___reserve"+// protoArgs: "(CasADi::Matrix< double >* obj, int x0)"+// args: "(x0_)"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__Matrix_double___reserve(CasADi::Matrix< double >* obj, int x0)"+// call: "obj->reserve(x0_)"+extern "C"+ void CasADi__Matrix_double___reserve(CasADi::Matrix< double >* obj, int x0);+void CasADi__Matrix_double___reserve(CasADi::Matrix< double >* obj, int x0){+ int x0_ = Marshaling<int,int>::marshal(x0);++ return obj->reserve(x0_);+}+++// ================== Normal method: "reserve'" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::reserve'"+// cWrapperName: "CasADi__Matrix_double___reserve_TIC"+// protoArgs: "(CasADi::Matrix< double >* obj, int x0, int x1)"+// args: "(x0_, x1_)"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__Matrix_double___reserve_TIC(CasADi::Matrix< double >* obj, int x0, int x1)"+// call: "obj->reserve(x0_, x1_)"+extern "C"+ void CasADi__Matrix_double___reserve_TIC(CasADi::Matrix< double >* obj, int x0, int x1);+void CasADi__Matrix_double___reserve_TIC(CasADi::Matrix< double >* obj, int x0, int x1){+ int x0_ = Marshaling<int,int>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);++ return obj->reserve(x0_, x1_);+}+++// ================== Normal method: "erase" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::erase"+// cWrapperName: "CasADi__Matrix_double___erase"+// protoArgs: "(CasADi::Matrix< double >* obj, std::vector<int > * x0, std::vector<int > * x1)"+// args: "(x0_, x1_)"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__Matrix_double___erase(CasADi::Matrix< double >* obj, std::vector<int > * x0, std::vector<int > * x1)"+// call: "obj->erase(x0_, x1_)"+extern "C"+ void CasADi__Matrix_double___erase(CasADi::Matrix< double >* obj, std::vector<int > * x0, std::vector<int > * x1);+void CasADi__Matrix_double___erase(CasADi::Matrix< double >* obj, std::vector<int > * x0, std::vector<int > * x1){+ std::vector<int > x0_ = Marshaling<std::vector<int >,std::vector<int > *>::marshal(x0);+ std::vector<int > x1_ = Marshaling<std::vector<int >,std::vector<int > *>::marshal(x1);++ return obj->erase(x0_, x1_);+}+++// ================== Normal method: "remove" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::remove"+// cWrapperName: "CasADi__Matrix_double___remove"+// protoArgs: "(CasADi::Matrix< double >* obj, std::vector<int > * x0, std::vector<int > * x1)"+// args: "(x0_, x1_)"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__Matrix_double___remove(CasADi::Matrix< double >* obj, std::vector<int > * x0, std::vector<int > * x1)"+// call: "obj->remove(x0_, x1_)"+extern "C"+ void CasADi__Matrix_double___remove(CasADi::Matrix< double >* obj, std::vector<int > * x0, std::vector<int > * x1);+void CasADi__Matrix_double___remove(CasADi::Matrix< double >* obj, std::vector<int > * x0, std::vector<int > * x1){+ std::vector<int > x0_ = Marshaling<std::vector<int >,std::vector<int > *>::marshal(x0);+ std::vector<int > x1_ = Marshaling<std::vector<int >,std::vector<int > *>::marshal(x1);++ return obj->remove(x0_, x1_);+}+++// ================== Normal method: "enlarge" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::enlarge"+// cWrapperName: "CasADi__Matrix_double___enlarge"+// protoArgs: "(CasADi::Matrix< double >* obj, int x0, int x1, std::vector<int > * x2, std::vector<int > * x3)"+// args: "(x0_, x1_, x2_, x3_)"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__Matrix_double___enlarge(CasADi::Matrix< double >* obj, int x0, int x1, std::vector<int > * x2, std::vector<int > * x3)"+// call: "obj->enlarge(x0_, x1_, x2_, x3_)"+extern "C"+ void CasADi__Matrix_double___enlarge(CasADi::Matrix< double >* obj, int x0, int x1, std::vector<int > * x2, std::vector<int > * x3);+void CasADi__Matrix_double___enlarge(CasADi::Matrix< double >* obj, int x0, int x1, std::vector<int > * x2, std::vector<int > * x3){+ int x0_ = Marshaling<int,int>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);+ std::vector<int > x2_ = Marshaling<std::vector<int >,std::vector<int > *>::marshal(x2);+ std::vector<int > x3_ = Marshaling<std::vector<int >,std::vector<int > *>::marshal(x3);++ return obj->enlarge(x0_, x1_, x2_, x3_);+}+++// ================== Normal method: "data" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::data"+// cWrapperName: "CasADi__Matrix_double___data"+// protoArgs: "(CasADi::Matrix< double >* obj)"+// args: "()"+// rettype: Val (Vec (NonVec CDouble))+// cWrapperRetType: "std::vector<double >*"+// proto: "std::vector<double >* CasADi__Matrix_double___data(CasADi::Matrix< double >* obj)"+// call: "obj->data()"+extern "C"+ std::vector<double >* CasADi__Matrix_double___data(CasADi::Matrix< double >* obj);+std::vector<double >* CasADi__Matrix_double___data(CasADi::Matrix< double >* obj){++ return new std::vector<double >( obj->data() );+}+++// ================== Normal method: "sparsityRef" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::sparsityRef"+// cWrapperName: "CasADi__Matrix_double___sparsityRef"+// protoArgs: "(CasADi::Matrix< double >* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass CRSSparsity))+// cWrapperRetType: "CasADi::CRSSparsity*"+// proto: "CasADi::CRSSparsity* CasADi__Matrix_double___sparsityRef(CasADi::Matrix< double >* obj)"+// call: "obj->sparsityRef()"+extern "C"+ CasADi::CRSSparsity* CasADi__Matrix_double___sparsityRef(CasADi::Matrix< double >* obj);+CasADi::CRSSparsity* CasADi__Matrix_double___sparsityRef(CasADi::Matrix< double >* obj){++ return new CasADi::CRSSparsity( obj->sparsityRef() );+}+++// ================== Normal method: "set" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::set"+// cWrapperName: "CasADi__Matrix_double___set"+// protoArgs: "(CasADi::Matrix< double >* obj, double x0, CasADi::Sparsity x1)"+// args: "(x0_, x1_)"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__Matrix_double___set(CasADi::Matrix< double >* obj, double x0, CasADi::Sparsity x1)"+// call: "obj->set(x0_, x1_)"+extern "C"+ void CasADi__Matrix_double___set(CasADi::Matrix< double >* obj, double x0, CasADi::Sparsity x1);+void CasADi__Matrix_double___set(CasADi::Matrix< double >* obj, double x0, CasADi::Sparsity x1){+ double x0_ = Marshaling<double,double>::marshal(x0);+ CasADi::Sparsity x1_ = Marshaling<CasADi::Sparsity,CasADi::Sparsity>::marshal(x1);++ return obj->set(x0_, x1_);+}+++// ================== Normal method: "set'" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::set'"+// cWrapperName: "CasADi__Matrix_double___set_TIC"+// protoArgs: "(CasADi::Matrix< double >* obj, double x0)"+// args: "(x0_)"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__Matrix_double___set_TIC(CasADi::Matrix< double >* obj, double x0)"+// call: "obj->set(x0_)"+extern "C"+ void CasADi__Matrix_double___set_TIC(CasADi::Matrix< double >* obj, double x0);+void CasADi__Matrix_double___set_TIC(CasADi::Matrix< double >* obj, double x0){+ double x0_ = Marshaling<double,double>::marshal(x0);++ return obj->set(x0_);+}+++// ================== Normal method: "get" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::get"+// cWrapperName: "CasADi__Matrix_double___get"+// protoArgs: "(CasADi::Matrix< double >* obj, double* x0, CasADi::Sparsity x1)"+// args: "(x0_, x1_)"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__Matrix_double___get(CasADi::Matrix< double >* obj, double* x0, CasADi::Sparsity x1)"+// call: "obj->get(x0_, x1_)"+extern "C"+ void CasADi__Matrix_double___get(CasADi::Matrix< double >* obj, double* x0, CasADi::Sparsity x1);+void CasADi__Matrix_double___get(CasADi::Matrix< double >* obj, double* x0, CasADi::Sparsity x1){+ double x0_ = Marshaling<double,double*>::marshal(x0);+ CasADi::Sparsity x1_ = Marshaling<CasADi::Sparsity,CasADi::Sparsity>::marshal(x1);++ return obj->get(x0_, x1_);+}+++// ================== Normal method: "get'" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::get'"+// cWrapperName: "CasADi__Matrix_double___get_TIC"+// protoArgs: "(CasADi::Matrix< double >* obj, double* x0)"+// args: "(x0_)"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__Matrix_double___get_TIC(CasADi::Matrix< double >* obj, double* x0)"+// call: "obj->get(x0_)"+extern "C"+ void CasADi__Matrix_double___get_TIC(CasADi::Matrix< double >* obj, double* x0);+void CasADi__Matrix_double___get_TIC(CasADi::Matrix< double >* obj, double* x0){+ double x0_ = Marshaling<double,double*>::marshal(x0);++ return obj->get(x0_);+}+++// ================== Normal method: "set''" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::set''"+// cWrapperName: "CasADi__Matrix_double___set_TIC_TIC"+// protoArgs: "(CasADi::Matrix< double >* obj, std::vector<double > * x0, CasADi::Sparsity x1)"+// args: "(x0_, x1_)"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__Matrix_double___set_TIC_TIC(CasADi::Matrix< double >* obj, std::vector<double > * x0, CasADi::Sparsity x1)"+// call: "obj->set(x0_, x1_)"+extern "C"+ void CasADi__Matrix_double___set_TIC_TIC(CasADi::Matrix< double >* obj, std::vector<double > * x0, CasADi::Sparsity x1);+void CasADi__Matrix_double___set_TIC_TIC(CasADi::Matrix< double >* obj, std::vector<double > * x0, CasADi::Sparsity x1){+ std::vector<double > x0_ = Marshaling<std::vector<double >,std::vector<double > *>::marshal(x0);+ CasADi::Sparsity x1_ = Marshaling<CasADi::Sparsity,CasADi::Sparsity>::marshal(x1);++ return obj->set(x0_, x1_);+}+++// ================== Normal method: "set'''" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::set'''"+// cWrapperName: "CasADi__Matrix_double___set_TIC_TIC_TIC"+// protoArgs: "(CasADi::Matrix< double >* obj, std::vector<double > * x0)"+// args: "(x0_)"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__Matrix_double___set_TIC_TIC_TIC(CasADi::Matrix< double >* obj, std::vector<double > * x0)"+// call: "obj->set(x0_)"+extern "C"+ void CasADi__Matrix_double___set_TIC_TIC_TIC(CasADi::Matrix< double >* obj, std::vector<double > * x0);+void CasADi__Matrix_double___set_TIC_TIC_TIC(CasADi::Matrix< double >* obj, std::vector<double > * x0){+ std::vector<double > x0_ = Marshaling<std::vector<double >,std::vector<double > *>::marshal(x0);++ return obj->set(x0_);+}+++// ================== Normal method: "get''" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::get''"+// cWrapperName: "CasADi__Matrix_double___get_TIC_TIC"+// protoArgs: "(CasADi::Matrix< double >* obj, std::vector<double >* x0, CasADi::Sparsity x1)"+// args: "(x0_, x1_)"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__Matrix_double___get_TIC_TIC(CasADi::Matrix< double >* obj, std::vector<double >* x0, CasADi::Sparsity x1)"+// call: "obj->get(x0_, x1_)"+extern "C"+ void CasADi__Matrix_double___get_TIC_TIC(CasADi::Matrix< double >* obj, std::vector<double >* x0, CasADi::Sparsity x1);+void CasADi__Matrix_double___get_TIC_TIC(CasADi::Matrix< double >* obj, std::vector<double >* x0, CasADi::Sparsity x1){+ std::vector<double > x0_ = Marshaling<std::vector<double >,std::vector<double >*>::marshal(x0);+ CasADi::Sparsity x1_ = Marshaling<CasADi::Sparsity,CasADi::Sparsity>::marshal(x1);++ return obj->get(x0_, x1_);+}+++// ================== Normal method: "get'''" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::get'''"+// cWrapperName: "CasADi__Matrix_double___get_TIC_TIC_TIC"+// protoArgs: "(CasADi::Matrix< double >* obj, std::vector<double >* x0)"+// args: "(x0_)"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__Matrix_double___get_TIC_TIC_TIC(CasADi::Matrix< double >* obj, std::vector<double >* x0)"+// call: "obj->get(x0_)"+extern "C"+ void CasADi__Matrix_double___get_TIC_TIC_TIC(CasADi::Matrix< double >* obj, std::vector<double >* x0);+void CasADi__Matrix_double___get_TIC_TIC_TIC(CasADi::Matrix< double >* obj, std::vector<double >* x0){+ std::vector<double > x0_ = Marshaling<std::vector<double >,std::vector<double >*>::marshal(x0);++ return obj->get(x0_);+}+++// ================== Normal method: "set''''" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::set''''"+// cWrapperName: "CasADi__Matrix_double___set_TIC_TIC_TIC_TIC"+// protoArgs: "(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0, CasADi::Sparsity x1)"+// args: "(x0_, x1_)"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__Matrix_double___set_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0, CasADi::Sparsity x1)"+// call: "obj->set(x0_, x1_)"+extern "C"+ void CasADi__Matrix_double___set_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0, CasADi::Sparsity x1);+void CasADi__Matrix_double___set_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0, CasADi::Sparsity x1){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);+ CasADi::Sparsity x1_ = Marshaling<CasADi::Sparsity,CasADi::Sparsity>::marshal(x1);++ return obj->set(x0_, x1_);+}+++// ================== Normal method: "set'''''" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::set'''''"+// cWrapperName: "CasADi__Matrix_double___set_TIC_TIC_TIC_TIC_TIC"+// protoArgs: "(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"+// args: "(x0_)"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__Matrix_double___set_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"+// call: "obj->set(x0_)"+extern "C"+ void CasADi__Matrix_double___set_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0);+void CasADi__Matrix_double___set_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);++ return obj->set(x0_);+}+++// ================== Normal method: "get''''" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::get''''"+// cWrapperName: "CasADi__Matrix_double___get_TIC_TIC_TIC_TIC"+// protoArgs: "(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0, CasADi::Sparsity x1)"+// args: "(x0_, x1_)"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__Matrix_double___get_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0, CasADi::Sparsity x1)"+// call: "obj->get(x0_, x1_)"+extern "C"+ void CasADi__Matrix_double___get_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0, CasADi::Sparsity x1);+void CasADi__Matrix_double___get_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0, CasADi::Sparsity x1){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);+ CasADi::Sparsity x1_ = Marshaling<CasADi::Sparsity,CasADi::Sparsity>::marshal(x1);++ return obj->get(x0_, x1_);+}+++// ================== Normal method: "get'''''" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::get'''''"+// cWrapperName: "CasADi__Matrix_double___get_TIC_TIC_TIC_TIC_TIC"+// protoArgs: "(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"+// args: "(x0_)"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__Matrix_double___get_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0)"+// call: "obj->get(x0_)"+extern "C"+ void CasADi__Matrix_double___get_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0);+void CasADi__Matrix_double___get_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* obj, CasADi::Matrix< double >* x0){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);++ return obj->get(x0_);+}+++// ================== Static method: "sparse" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::sparse"+// cWrapperName: "CasADi__Matrix_double___sparse"+// protoArgs: "(int x0, int x1)"+// args: "(x0_, x1_)"+// rettype: Val (NonVec (CasadiClass DMatrix))+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___sparse(int x0, int x1)"+// call: "CasADi::Matrix< double >::sparse(x0_, x1_)"+extern "C"+ CasADi::Matrix< double >* CasADi__Matrix_double___sparse(int x0, int x1);+CasADi::Matrix< double >* CasADi__Matrix_double___sparse(int x0, int x1){+ int x0_ = Marshaling<int,int>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);++ return new CasADi::Matrix< double >( CasADi::Matrix< double >::sparse(x0_, x1_) );+}+++// ================== Static method: "sparse'" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::sparse'"+// cWrapperName: "CasADi__Matrix_double___sparse_TIC"+// protoArgs: "(int x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass DMatrix))+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___sparse_TIC(int x0)"+// call: "CasADi::Matrix< double >::sparse(x0_)"+extern "C"+ CasADi::Matrix< double >* CasADi__Matrix_double___sparse_TIC(int x0);+CasADi::Matrix< double >* CasADi__Matrix_double___sparse_TIC(int x0){+ int x0_ = Marshaling<int,int>::marshal(x0);++ return new CasADi::Matrix< double >( CasADi::Matrix< double >::sparse(x0_) );+}+++// ================== Static method: "sparse''" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::sparse''"+// cWrapperName: "CasADi__Matrix_double___sparse_TIC_TIC"+// protoArgs: "(std::vector<int > * x0, std::vector<int > * x1, std::vector<double > * x2)"+// args: "(x0_, x1_, x2_)"+// rettype: Val (NonVec (CasadiClass DMatrix))+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___sparse_TIC_TIC(std::vector<int > * x0, std::vector<int > * x1, std::vector<double > * x2)"+// call: "CasADi::Matrix< double >::sparse(x0_, x1_, x2_)"+extern "C"+ CasADi::Matrix< double >* CasADi__Matrix_double___sparse_TIC_TIC(std::vector<int > * x0, std::vector<int > * x1, std::vector<double > * x2);+CasADi::Matrix< double >* CasADi__Matrix_double___sparse_TIC_TIC(std::vector<int > * x0, std::vector<int > * x1, std::vector<double > * x2){+ std::vector<int > x0_ = Marshaling<std::vector<int >,std::vector<int > *>::marshal(x0);+ std::vector<int > x1_ = Marshaling<std::vector<int >,std::vector<int > *>::marshal(x1);+ std::vector<double > x2_ = Marshaling<std::vector<double >,std::vector<double > *>::marshal(x2);++ return new CasADi::Matrix< double >( CasADi::Matrix< double >::sparse(x0_, x1_, x2_) );+}+++// ================== Static method: "sparse'''" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::sparse'''"+// cWrapperName: "CasADi__Matrix_double___sparse_TIC_TIC_TIC"+// protoArgs: "(std::vector<int > * x0, std::vector<int > * x1, std::vector<double > * x2, int x3, int x4)"+// args: "(x0_, x1_, x2_, x3_, x4_)"+// rettype: Val (NonVec (CasadiClass DMatrix))+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___sparse_TIC_TIC_TIC(std::vector<int > * x0, std::vector<int > * x1, std::vector<double > * x2, int x3, int x4)"+// call: "CasADi::Matrix< double >::sparse(x0_, x1_, x2_, x3_, x4_)"+extern "C"+ CasADi::Matrix< double >* CasADi__Matrix_double___sparse_TIC_TIC_TIC(std::vector<int > * x0, std::vector<int > * x1, std::vector<double > * x2, int x3, int x4);+CasADi::Matrix< double >* CasADi__Matrix_double___sparse_TIC_TIC_TIC(std::vector<int > * x0, std::vector<int > * x1, std::vector<double > * x2, int x3, int x4){+ std::vector<int > x0_ = Marshaling<std::vector<int >,std::vector<int > *>::marshal(x0);+ std::vector<int > x1_ = Marshaling<std::vector<int >,std::vector<int > *>::marshal(x1);+ std::vector<double > x2_ = Marshaling<std::vector<double >,std::vector<double > *>::marshal(x2);+ int x3_ = Marshaling<int,int>::marshal(x3);+ int x4_ = Marshaling<int,int>::marshal(x4);++ return new CasADi::Matrix< double >( CasADi::Matrix< double >::sparse(x0_, x1_, x2_, x3_, x4_) );+}+++// ================== Static method: "zeros" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::zeros"+// cWrapperName: "CasADi__Matrix_double___zeros"+// protoArgs: "(CasADi::CRSSparsity* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass DMatrix))+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___zeros(CasADi::CRSSparsity* x0)"+// call: "CasADi::Matrix< double >::zeros(x0_)"+extern "C"+ CasADi::Matrix< double >* CasADi__Matrix_double___zeros(CasADi::CRSSparsity* x0);+CasADi::Matrix< double >* CasADi__Matrix_double___zeros(CasADi::CRSSparsity* x0){+ CasADi::CRSSparsity x0_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x0);++ return new CasADi::Matrix< double >( CasADi::Matrix< double >::zeros(x0_) );+}+++// ================== Static method: "zeros'" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::zeros'"+// cWrapperName: "CasADi__Matrix_double___zeros_TIC"+// protoArgs: "(int x0, int x1)"+// args: "(x0_, x1_)"+// rettype: Val (NonVec (CasadiClass DMatrix))+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___zeros_TIC(int x0, int x1)"+// call: "CasADi::Matrix< double >::zeros(x0_, x1_)"+extern "C"+ CasADi::Matrix< double >* CasADi__Matrix_double___zeros_TIC(int x0, int x1);+CasADi::Matrix< double >* CasADi__Matrix_double___zeros_TIC(int x0, int x1){+ int x0_ = Marshaling<int,int>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);++ return new CasADi::Matrix< double >( CasADi::Matrix< double >::zeros(x0_, x1_) );+}+++// ================== Static method: "zeros''" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::zeros''"+// cWrapperName: "CasADi__Matrix_double___zeros_TIC_TIC"+// protoArgs: "(int x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass DMatrix))+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___zeros_TIC_TIC(int x0)"+// call: "CasADi::Matrix< double >::zeros(x0_)"+extern "C"+ CasADi::Matrix< double >* CasADi__Matrix_double___zeros_TIC_TIC(int x0);+CasADi::Matrix< double >* CasADi__Matrix_double___zeros_TIC_TIC(int x0){+ int x0_ = Marshaling<int,int>::marshal(x0);++ return new CasADi::Matrix< double >( CasADi::Matrix< double >::zeros(x0_) );+}+++// ================== Static method: "ones" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::ones"+// cWrapperName: "CasADi__Matrix_double___ones"+// protoArgs: "(CasADi::CRSSparsity* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass DMatrix))+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___ones(CasADi::CRSSparsity* x0)"+// call: "CasADi::Matrix< double >::ones(x0_)"+extern "C"+ CasADi::Matrix< double >* CasADi__Matrix_double___ones(CasADi::CRSSparsity* x0);+CasADi::Matrix< double >* CasADi__Matrix_double___ones(CasADi::CRSSparsity* x0){+ CasADi::CRSSparsity x0_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x0);++ return new CasADi::Matrix< double >( CasADi::Matrix< double >::ones(x0_) );+}+++// ================== Static method: "ones'" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::ones'"+// cWrapperName: "CasADi__Matrix_double___ones_TIC"+// protoArgs: "(int x0, int x1)"+// args: "(x0_, x1_)"+// rettype: Val (NonVec (CasadiClass DMatrix))+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___ones_TIC(int x0, int x1)"+// call: "CasADi::Matrix< double >::ones(x0_, x1_)"+extern "C"+ CasADi::Matrix< double >* CasADi__Matrix_double___ones_TIC(int x0, int x1);+CasADi::Matrix< double >* CasADi__Matrix_double___ones_TIC(int x0, int x1){+ int x0_ = Marshaling<int,int>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);++ return new CasADi::Matrix< double >( CasADi::Matrix< double >::ones(x0_, x1_) );+}+++// ================== Static method: "ones''" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::ones''"+// cWrapperName: "CasADi__Matrix_double___ones_TIC_TIC"+// protoArgs: "(int x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass DMatrix))+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___ones_TIC_TIC(int x0)"+// call: "CasADi::Matrix< double >::ones(x0_)"+extern "C"+ CasADi::Matrix< double >* CasADi__Matrix_double___ones_TIC_TIC(int x0);+CasADi::Matrix< double >* CasADi__Matrix_double___ones_TIC_TIC(int x0){+ int x0_ = Marshaling<int,int>::marshal(x0);++ return new CasADi::Matrix< double >( CasADi::Matrix< double >::ones(x0_) );+}+++// ================== Static method: "inf" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::inf"+// cWrapperName: "CasADi__Matrix_double___inf"+// protoArgs: "(CasADi::CRSSparsity* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass DMatrix))+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___inf(CasADi::CRSSparsity* x0)"+// call: "CasADi::Matrix< double >::inf(x0_)"+extern "C"+ CasADi::Matrix< double >* CasADi__Matrix_double___inf(CasADi::CRSSparsity* x0);+CasADi::Matrix< double >* CasADi__Matrix_double___inf(CasADi::CRSSparsity* x0){+ CasADi::CRSSparsity x0_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x0);++ return new CasADi::Matrix< double >( CasADi::Matrix< double >::inf(x0_) );+}+++// ================== Static method: "inf'" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::inf'"+// cWrapperName: "CasADi__Matrix_double___inf_TIC"+// protoArgs: "(int x0, int x1)"+// args: "(x0_, x1_)"+// rettype: Val (NonVec (CasadiClass DMatrix))+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___inf_TIC(int x0, int x1)"+// call: "CasADi::Matrix< double >::inf(x0_, x1_)"+extern "C"+ CasADi::Matrix< double >* CasADi__Matrix_double___inf_TIC(int x0, int x1);+CasADi::Matrix< double >* CasADi__Matrix_double___inf_TIC(int x0, int x1){+ int x0_ = Marshaling<int,int>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);++ return new CasADi::Matrix< double >( CasADi::Matrix< double >::inf(x0_, x1_) );+}+++// ================== Static method: "inf''" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::inf''"+// cWrapperName: "CasADi__Matrix_double___inf_TIC_TIC"+// protoArgs: "(int x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass DMatrix))+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___inf_TIC_TIC(int x0)"+// call: "CasADi::Matrix< double >::inf(x0_)"+extern "C"+ CasADi::Matrix< double >* CasADi__Matrix_double___inf_TIC_TIC(int x0);+CasADi::Matrix< double >* CasADi__Matrix_double___inf_TIC_TIC(int x0){+ int x0_ = Marshaling<int,int>::marshal(x0);++ return new CasADi::Matrix< double >( CasADi::Matrix< double >::inf(x0_) );+}+++// ================== Static method: "inf'''" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::inf'''"+// cWrapperName: "CasADi__Matrix_double___inf_TIC_TIC_TIC"+// protoArgs: "()"+// args: "()"+// rettype: Val (NonVec (CasadiClass DMatrix))+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___inf_TIC_TIC_TIC()"+// call: "CasADi::Matrix< double >::inf()"+extern "C"+ CasADi::Matrix< double >* CasADi__Matrix_double___inf_TIC_TIC_TIC();+CasADi::Matrix< double >* CasADi__Matrix_double___inf_TIC_TIC_TIC(){++ return new CasADi::Matrix< double >( CasADi::Matrix< double >::inf() );+}+++// ================== Static method: "nan" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::nan"+// cWrapperName: "CasADi__Matrix_double___nan"+// protoArgs: "(CasADi::CRSSparsity* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass DMatrix))+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___nan(CasADi::CRSSparsity* x0)"+// call: "CasADi::Matrix< double >::nan(x0_)"+extern "C"+ CasADi::Matrix< double >* CasADi__Matrix_double___nan(CasADi::CRSSparsity* x0);+CasADi::Matrix< double >* CasADi__Matrix_double___nan(CasADi::CRSSparsity* x0){+ CasADi::CRSSparsity x0_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x0);++ return new CasADi::Matrix< double >( CasADi::Matrix< double >::nan(x0_) );+}+++// ================== Static method: "nan'" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::nan'"+// cWrapperName: "CasADi__Matrix_double___nan_TIC"+// protoArgs: "(int x0, int x1)"+// args: "(x0_, x1_)"+// rettype: Val (NonVec (CasadiClass DMatrix))+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___nan_TIC(int x0, int x1)"+// call: "CasADi::Matrix< double >::nan(x0_, x1_)"+extern "C"+ CasADi::Matrix< double >* CasADi__Matrix_double___nan_TIC(int x0, int x1);+CasADi::Matrix< double >* CasADi__Matrix_double___nan_TIC(int x0, int x1){+ int x0_ = Marshaling<int,int>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);++ return new CasADi::Matrix< double >( CasADi::Matrix< double >::nan(x0_, x1_) );+}+++// ================== Static method: "nan''" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::nan''"+// cWrapperName: "CasADi__Matrix_double___nan_TIC_TIC"+// protoArgs: "(int x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass DMatrix))+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___nan_TIC_TIC(int x0)"+// call: "CasADi::Matrix< double >::nan(x0_)"+extern "C"+ CasADi::Matrix< double >* CasADi__Matrix_double___nan_TIC_TIC(int x0);+CasADi::Matrix< double >* CasADi__Matrix_double___nan_TIC_TIC(int x0){+ int x0_ = Marshaling<int,int>::marshal(x0);++ return new CasADi::Matrix< double >( CasADi::Matrix< double >::nan(x0_) );+}+++// ================== Static method: "nan'''" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::nan'''"+// cWrapperName: "CasADi__Matrix_double___nan_TIC_TIC_TIC"+// protoArgs: "()"+// args: "()"+// rettype: Val (NonVec (CasadiClass DMatrix))+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___nan_TIC_TIC_TIC()"+// call: "CasADi::Matrix< double >::nan()"+extern "C"+ CasADi::Matrix< double >* CasADi__Matrix_double___nan_TIC_TIC_TIC();+CasADi::Matrix< double >* CasADi__Matrix_double___nan_TIC_TIC_TIC(){++ return new CasADi::Matrix< double >( CasADi::Matrix< double >::nan() );+}+++// ================== Static method: "repmat" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::repmat"+// cWrapperName: "CasADi__Matrix_double___repmat"+// protoArgs: "(CasADi::Matrix< double >* x0, int x1, int x2)"+// args: "(x0_, x1_, x2_)"+// rettype: Val (NonVec (CasadiClass DMatrix))+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___repmat(CasADi::Matrix< double >* x0, int x1, int x2)"+// call: "CasADi::Matrix< double >::repmat(x0_, x1_, x2_)"+extern "C"+ CasADi::Matrix< double >* CasADi__Matrix_double___repmat(CasADi::Matrix< double >* x0, int x1, int x2);+CasADi::Matrix< double >* CasADi__Matrix_double___repmat(CasADi::Matrix< double >* x0, int x1, int x2){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);+ int x2_ = Marshaling<int,int>::marshal(x2);++ return new CasADi::Matrix< double >( CasADi::Matrix< double >::repmat(x0_, x1_, x2_) );+}+++// ================== Static method: "repmat'" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::repmat'"+// cWrapperName: "CasADi__Matrix_double___repmat_TIC"+// protoArgs: "(CasADi::Matrix< double >* x0, int x1)"+// args: "(x0_, x1_)"+// rettype: Val (NonVec (CasadiClass DMatrix))+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___repmat_TIC(CasADi::Matrix< double >* x0, int x1)"+// call: "CasADi::Matrix< double >::repmat(x0_, x1_)"+extern "C"+ CasADi::Matrix< double >* CasADi__Matrix_double___repmat_TIC(CasADi::Matrix< double >* x0, int x1);+CasADi::Matrix< double >* CasADi__Matrix_double___repmat_TIC(CasADi::Matrix< double >* x0, int x1){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);++ return new CasADi::Matrix< double >( CasADi::Matrix< double >::repmat(x0_, x1_) );+}+++// ================== Static method: "eye" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::eye"+// cWrapperName: "CasADi__Matrix_double___eye"+// protoArgs: "(int x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass DMatrix))+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___eye(int x0)"+// call: "CasADi::Matrix< double >::eye(x0_)"+extern "C"+ CasADi::Matrix< double >* CasADi__Matrix_double___eye(int x0);+CasADi::Matrix< double >* CasADi__Matrix_double___eye(int x0){+ int x0_ = Marshaling<int,int>::marshal(x0);++ return new CasADi::Matrix< double >( CasADi::Matrix< double >::eye(x0_) );+}+++// ================== Normal method: "isNull" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::isNull"+// cWrapperName: "CasADi__Matrix_double___isNull"+// protoArgs: "(CasADi::Matrix< double >* obj)"+// args: "()"+// rettype: Val (NonVec CBool)+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__Matrix_double___isNull(CasADi::Matrix< double >* obj)"+// call: "obj->isNull()"+extern "C"+ bool* CasADi__Matrix_double___isNull(CasADi::Matrix< double >* obj);+bool* CasADi__Matrix_double___isNull(CasADi::Matrix< double >* obj){++ return new bool( obj->isNull() );+}+++// ================== Static method: "setPrecision" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::setPrecision"+// cWrapperName: "CasADi__Matrix_double___setPrecision"+// protoArgs: "(int x0)"+// args: "(x0_)"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__Matrix_double___setPrecision(int x0)"+// call: "CasADi::Matrix< double >::setPrecision(x0_)"+extern "C"+ void CasADi__Matrix_double___setPrecision(int x0);+void CasADi__Matrix_double___setPrecision(int x0){+ int x0_ = Marshaling<int,int>::marshal(x0);++ return CasADi::Matrix< double >::setPrecision(x0_);+}+++// ================== Static method: "setWidth" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::setWidth"+// cWrapperName: "CasADi__Matrix_double___setWidth"+// protoArgs: "(int x0)"+// args: "(x0_)"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__Matrix_double___setWidth(int x0)"+// call: "CasADi::Matrix< double >::setWidth(x0_)"+extern "C"+ void CasADi__Matrix_double___setWidth(int x0);+void CasADi__Matrix_double___setWidth(int x0){+ int x0_ = Marshaling<int,int>::marshal(x0);++ return CasADi::Matrix< double >::setWidth(x0_);+}+++// ================== Static method: "setScientific" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >::setScientific"+// cWrapperName: "CasADi__Matrix_double___setScientific"+// protoArgs: "(bool* x0)"+// args: "(x0_)"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__Matrix_double___setScientific(bool* x0)"+// call: "CasADi::Matrix< double >::setScientific(x0_)"+extern "C"+ void CasADi__Matrix_double___setScientific(bool* x0);+void CasADi__Matrix_double___setScientific(bool* x0){+ bool x0_ = Marshaling<bool,bool*>::marshal(x0);++ return CasADi::Matrix< double >::setScientific(x0_);+}+++// ================== Constructor method: "DMatrix" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >"+// cWrapperName: "CasADi__Matrix_double___DMatrix"+// protoArgs: "()"+// args: "()"+// rettype: Val (NonVec (CasadiClass DMatrix))+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix()"+// call: "CasADi::Matrix< double >()"+extern "C"+ CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix();+CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix(){++ return new CasADi::Matrix< double >( CasADi::Matrix< double >() );+}+++// ================== Constructor method: "DMatrix'" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >"+// cWrapperName: "CasADi__Matrix_double___DMatrix_TIC"+// protoArgs: "(CasADi::Matrix< double >* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass DMatrix))+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix_TIC(CasADi::Matrix< double >* x0)"+// call: "CasADi::Matrix< double >(x0_)"+extern "C"+ CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix_TIC(CasADi::Matrix< double >* x0);+CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix_TIC(CasADi::Matrix< double >* x0){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);++ return new CasADi::Matrix< double >( CasADi::Matrix< double >(x0_) );+}+++// ================== Constructor method: "DMatrix''" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >"+// cWrapperName: "CasADi__Matrix_double___DMatrix_TIC_TIC"+// protoArgs: "(int x0, int x1)"+// args: "(x0_, x1_)"+// rettype: Val (NonVec (CasadiClass DMatrix))+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix_TIC_TIC(int x0, int x1)"+// call: "CasADi::Matrix< double >(x0_, x1_)"+extern "C"+ CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix_TIC_TIC(int x0, int x1);+CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix_TIC_TIC(int x0, int x1){+ int x0_ = Marshaling<int,int>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);++ return new CasADi::Matrix< double >( CasADi::Matrix< double >(x0_, x1_) );+}+++// ================== Constructor method: "DMatrix'''" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >"+// cWrapperName: "CasADi__Matrix_double___DMatrix_TIC_TIC_TIC"+// protoArgs: "(int x0, int x1, double* x2)"+// args: "(x0_, x1_, x2_)"+// rettype: Val (NonVec (CasadiClass DMatrix))+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix_TIC_TIC_TIC(int x0, int x1, double* x2)"+// call: "CasADi::Matrix< double >(x0_, x1_, x2_)"+extern "C"+ CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix_TIC_TIC_TIC(int x0, int x1, double* x2);+CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix_TIC_TIC_TIC(int x0, int x1, double* x2){+ int x0_ = Marshaling<int,int>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);+ double x2_ = Marshaling<double,double*>::marshal(x2);++ return new CasADi::Matrix< double >( CasADi::Matrix< double >(x0_, x1_, x2_) );+}+++// ================== Constructor method: "DMatrix''''" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >"+// cWrapperName: "CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC"+// protoArgs: "(int x0, int x1, std::vector<int > * x2, std::vector<int > * x3, std::vector<double > * x4)"+// args: "(x0_, x1_, x2_, x3_, x4_)"+// rettype: Val (NonVec (CasadiClass DMatrix))+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC(int x0, int x1, std::vector<int > * x2, std::vector<int > * x3, std::vector<double > * x4)"+// call: "CasADi::Matrix< double >(x0_, x1_, x2_, x3_, x4_)"+extern "C"+ CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC(int x0, int x1, std::vector<int > * x2, std::vector<int > * x3, std::vector<double > * x4);+CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC(int x0, int x1, std::vector<int > * x2, std::vector<int > * x3, std::vector<double > * x4){+ int x0_ = Marshaling<int,int>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);+ std::vector<int > x2_ = Marshaling<std::vector<int >,std::vector<int > *>::marshal(x2);+ std::vector<int > x3_ = Marshaling<std::vector<int >,std::vector<int > *>::marshal(x3);+ std::vector<double > x4_ = Marshaling<std::vector<double >,std::vector<double > *>::marshal(x4);++ return new CasADi::Matrix< double >( CasADi::Matrix< double >(x0_, x1_, x2_, x3_, x4_) );+}+++// ================== Constructor method: "DMatrix'''''" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >"+// cWrapperName: "CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC"+// protoArgs: "(int x0, int x1, std::vector<int > * x2, std::vector<int > * x3)"+// args: "(x0_, x1_, x2_, x3_)"+// rettype: Val (NonVec (CasadiClass DMatrix))+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC(int x0, int x1, std::vector<int > * x2, std::vector<int > * x3)"+// call: "CasADi::Matrix< double >(x0_, x1_, x2_, x3_)"+extern "C"+ CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC(int x0, int x1, std::vector<int > * x2, std::vector<int > * x3);+CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC(int x0, int x1, std::vector<int > * x2, std::vector<int > * x3){+ int x0_ = Marshaling<int,int>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);+ std::vector<int > x2_ = Marshaling<std::vector<int >,std::vector<int > *>::marshal(x2);+ std::vector<int > x3_ = Marshaling<std::vector<int >,std::vector<int > *>::marshal(x3);++ return new CasADi::Matrix< double >( CasADi::Matrix< double >(x0_, x1_, x2_, x3_) );+}+++// ================== Constructor method: "DMatrix''''''" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >"+// cWrapperName: "CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC"+// protoArgs: "(std::vector<std::vector<double > > * x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass DMatrix))+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC(std::vector<std::vector<double > > * x0)"+// call: "CasADi::Matrix< double >(x0_)"+extern "C"+ CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC(std::vector<std::vector<double > > * x0);+CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC(std::vector<std::vector<double > > * x0){+ std::vector<std::vector<double > > x0_ = Marshaling<std::vector<std::vector<double > >,std::vector<std::vector<double > > *>::marshal(x0);++ return new CasADi::Matrix< double >( CasADi::Matrix< double >(x0_) );+}+++// ================== Constructor method: "DMatrix'''''''" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >"+// cWrapperName: "CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC"+// protoArgs: "(CasADi::CRSSparsity* x0, double* x1)"+// args: "(x0_, x1_)"+// rettype: Val (NonVec (CasadiClass DMatrix))+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::CRSSparsity* x0, double* x1)"+// call: "CasADi::Matrix< double >(x0_, x1_)"+extern "C"+ CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::CRSSparsity* x0, double* x1);+CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::CRSSparsity* x0, double* x1){+ CasADi::CRSSparsity x0_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x0);+ double x1_ = Marshaling<double,double*>::marshal(x1);++ return new CasADi::Matrix< double >( CasADi::Matrix< double >(x0_, x1_) );+}+++// ================== Constructor method: "DMatrix''''''''" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >"+// cWrapperName: "CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"+// protoArgs: "(CasADi::CRSSparsity* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass DMatrix))+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::CRSSparsity* x0)"+// call: "CasADi::Matrix< double >(x0_)"+extern "C"+ CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::CRSSparsity* x0);+CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::CRSSparsity* x0){+ CasADi::CRSSparsity x0_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x0);++ return new CasADi::Matrix< double >( CasADi::Matrix< double >(x0_) );+}+++// ================== Constructor method: "DMatrix'''''''''" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >"+// cWrapperName: "CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"+// protoArgs: "(CasADi::CRSSparsity* x0, std::vector<double > * x1)"+// args: "(x0_, x1_)"+// rettype: Val (NonVec (CasadiClass DMatrix))+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::CRSSparsity* x0, std::vector<double > * x1)"+// call: "CasADi::Matrix< double >(x0_, x1_)"+extern "C"+ CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::CRSSparsity* x0, std::vector<double > * x1);+CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::CRSSparsity* x0, std::vector<double > * x1){+ CasADi::CRSSparsity x0_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x0);+ std::vector<double > x1_ = Marshaling<std::vector<double >,std::vector<double > *>::marshal(x1);++ return new CasADi::Matrix< double >( CasADi::Matrix< double >(x0_, x1_) );+}+++// ================== Constructor method: "DMatrix''''''''''" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >"+// cWrapperName: "CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"+// protoArgs: "(double x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass DMatrix))+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(double x0)"+// call: "CasADi::Matrix< double >(x0_)"+extern "C"+ CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(double x0);+CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(double x0){+ double x0_ = Marshaling<double,double>::marshal(x0);++ return new CasADi::Matrix< double >( CasADi::Matrix< double >(x0_) );+}+++// ================== Constructor method: "DMatrix'''''''''''" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >"+// cWrapperName: "CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"+// protoArgs: "(std::vector<double > * x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass DMatrix))+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector<double > * x0)"+// call: "CasADi::Matrix< double >(x0_)"+extern "C"+ CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector<double > * x0);+CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector<double > * x0){+ std::vector<double > x0_ = Marshaling<std::vector<double >,std::vector<double > *>::marshal(x0);++ return new CasADi::Matrix< double >( CasADi::Matrix< double >(x0_) );+}+++// ================== Constructor method: "DMatrix''''''''''''" ===============+// class: "CasADi::Matrix< double >"+// cppName: "CasADi::Matrix< double >"+// cWrapperName: "CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"+// protoArgs: "(std::vector<double > * x0, int x1, int x2)"+// args: "(x0_, x1_, x2_)"+// rettype: Val (NonVec (CasadiClass DMatrix))+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector<double > * x0, int x1, int x2)"+// call: "CasADi::Matrix< double >(x0_, x1_, x2_)"+extern "C"+ CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector<double > * x0, int x1, int x2);+CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector<double > * x0, int x1, int x2){+ std::vector<double > x0_ = Marshaling<std::vector<double >,std::vector<double > *>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);+ int x2_ = Marshaling<int,int>::marshal(x2);++ return new CasADi::Matrix< double >( CasADi::Matrix< double >(x0_, x1_, x2_) );+}+++// ================== delete CasadiClass MX===============+// classType: CasadiClass MX+extern "C"+ void delete_CasADi__MX(CasADi::MX* obj);+void delete_CasADi__MX(CasADi::MX* obj){+ delete obj;+}+extern "C"+ void delete_std__vector_CasADi__MX_(std::vector<CasADi::MX* >* obj);+void delete_std__vector_CasADi__MX_(std::vector<CasADi::MX* >* obj){+ delete obj;+}+extern "C"+ void delete_std__vector_std__vector_CasADi__MX__(std::vector<std::vector<CasADi::MX* > >* obj);+void delete_std__vector_std__vector_CasADi__MX__(std::vector<std::vector<CasADi::MX* > >* obj){+ delete obj;+}+extern "C"+ void delete_std__vector_std__vector_std__vector_CasADi__MX___(std::vector<std::vector<std::vector<CasADi::MX* > > >* obj);+void delete_std__vector_std__vector_std__vector_CasADi__MX___(std::vector<std::vector<std::vector<CasADi::MX* > > >* obj){+ delete obj;+}++// ================== Normal method: "size1" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::size1"+// cWrapperName: "CasADi__MX__size1"+// protoArgs: "(CasADi::MX* obj)"+// args: "()"+// rettype: Val (NonVec CInt)+// cWrapperRetType: "int"+// proto: "int CasADi__MX__size1(CasADi::MX* obj)"+// call: "obj->size1()"+extern "C"+ int CasADi__MX__size1(CasADi::MX* obj);+int CasADi__MX__size1(CasADi::MX* obj){++ return obj->size1();+}+++// ================== Normal method: "size2" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::size2"+// cWrapperName: "CasADi__MX__size2"+// protoArgs: "(CasADi::MX* obj)"+// args: "()"+// rettype: Val (NonVec CInt)+// cWrapperRetType: "int"+// proto: "int CasADi__MX__size2(CasADi::MX* obj)"+// call: "obj->size2()"+extern "C"+ int CasADi__MX__size2(CasADi::MX* obj);+int CasADi__MX__size2(CasADi::MX* obj){++ return obj->size2();+}+++// ================== Normal method: "size" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::size"+// cWrapperName: "CasADi__MX__size"+// protoArgs: "(CasADi::MX* obj)"+// args: "()"+// rettype: Val (NonVec CInt)+// cWrapperRetType: "int"+// proto: "int CasADi__MX__size(CasADi::MX* obj)"+// call: "obj->size()"+extern "C"+ int CasADi__MX__size(CasADi::MX* obj);+int CasADi__MX__size(CasADi::MX* obj){++ return obj->size();+}+++// ================== Normal method: "numel" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::numel"+// cWrapperName: "CasADi__MX__numel"+// protoArgs: "(CasADi::MX* obj)"+// args: "()"+// rettype: Val (NonVec CInt)+// cWrapperRetType: "int"+// proto: "int CasADi__MX__numel(CasADi::MX* obj)"+// call: "obj->numel()"+extern "C"+ int CasADi__MX__numel(CasADi::MX* obj);+int CasADi__MX__numel(CasADi::MX* obj){++ return obj->numel();+}+++// ================== Normal method: "__nonzero__" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::__nonzero__"+// cWrapperName: "CasADi__MX____nonzero__"+// protoArgs: "(CasADi::MX* obj)"+// args: "()"+// rettype: Val (NonVec CBool)+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__MX____nonzero__(CasADi::MX* obj)"+// call: "obj->__nonzero__()"+extern "C"+ bool* CasADi__MX____nonzero__(CasADi::MX* obj);+bool* CasADi__MX____nonzero__(CasADi::MX* obj){++ return new bool( obj->__nonzero__() );+}+++// ================== Normal method: "sparsityRef" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::sparsityRef"+// cWrapperName: "CasADi__MX__sparsityRef"+// protoArgs: "(CasADi::MX* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass CRSSparsity))+// cWrapperRetType: "CasADi::CRSSparsity*"+// proto: "CasADi::CRSSparsity* CasADi__MX__sparsityRef(CasADi::MX* obj)"+// call: "obj->sparsityRef()"+extern "C"+ CasADi::CRSSparsity* CasADi__MX__sparsityRef(CasADi::MX* obj);+CasADi::CRSSparsity* CasADi__MX__sparsityRef(CasADi::MX* obj){++ return new CasADi::CRSSparsity( obj->sparsityRef() );+}+++// ================== Normal method: "erase" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::erase"+// cWrapperName: "CasADi__MX__erase"+// protoArgs: "(CasADi::MX* obj, std::vector<int > * x0, std::vector<int > * x1)"+// args: "(x0_, x1_)"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__MX__erase(CasADi::MX* obj, std::vector<int > * x0, std::vector<int > * x1)"+// call: "obj->erase(x0_, x1_)"+extern "C"+ void CasADi__MX__erase(CasADi::MX* obj, std::vector<int > * x0, std::vector<int > * x1);+void CasADi__MX__erase(CasADi::MX* obj, std::vector<int > * x0, std::vector<int > * x1){+ std::vector<int > x0_ = Marshaling<std::vector<int >,std::vector<int > *>::marshal(x0);+ std::vector<int > x1_ = Marshaling<std::vector<int >,std::vector<int > *>::marshal(x1);++ return obj->erase(x0_, x1_);+}+++// ================== Normal method: "enlarge" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::enlarge"+// cWrapperName: "CasADi__MX__enlarge"+// protoArgs: "(CasADi::MX* obj, int x0, int x1, std::vector<int > * x2, std::vector<int > * x3)"+// args: "(x0_, x1_, x2_, x3_)"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__MX__enlarge(CasADi::MX* obj, int x0, int x1, std::vector<int > * x2, std::vector<int > * x3)"+// call: "obj->enlarge(x0_, x1_, x2_, x3_)"+extern "C"+ void CasADi__MX__enlarge(CasADi::MX* obj, int x0, int x1, std::vector<int > * x2, std::vector<int > * x3);+void CasADi__MX__enlarge(CasADi::MX* obj, int x0, int x1, std::vector<int > * x2, std::vector<int > * x3){+ int x0_ = Marshaling<int,int>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);+ std::vector<int > x2_ = Marshaling<std::vector<int >,std::vector<int > *>::marshal(x2);+ std::vector<int > x3_ = Marshaling<std::vector<int >,std::vector<int > *>::marshal(x3);++ return obj->enlarge(x0_, x1_, x2_, x3_);+}+++// ================== Normal method: "operator -" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::operator -"+// cWrapperName: "CasADi__MX__operator_minus"+// protoArgs: "(CasADi::MX* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass MX))+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__MX__operator_minus(CasADi::MX* obj)"+// call: "obj->operator -()"+extern "C"+ CasADi::MX* CasADi__MX__operator_minus(CasADi::MX* obj);+CasADi::MX* CasADi__MX__operator_minus(CasADi::MX* obj){++ return new CasADi::MX( obj->operator -() );+}+++// ================== Normal method: "getDep" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::getDep"+// cWrapperName: "CasADi__MX__getDep"+// protoArgs: "(CasADi::MX* obj, int x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass MX))+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__MX__getDep(CasADi::MX* obj, int x0)"+// call: "obj->getDep(x0_)"+extern "C"+ CasADi::MX* CasADi__MX__getDep(CasADi::MX* obj, int x0);+CasADi::MX* CasADi__MX__getDep(CasADi::MX* obj, int x0){+ int x0_ = Marshaling<int,int>::marshal(x0);++ return new CasADi::MX( obj->getDep(x0_) );+}+++// ================== Normal method: "getDep'" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::getDep'"+// cWrapperName: "CasADi__MX__getDep_TIC"+// protoArgs: "(CasADi::MX* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass MX))+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__MX__getDep_TIC(CasADi::MX* obj)"+// call: "obj->getDep()"+extern "C"+ CasADi::MX* CasADi__MX__getDep_TIC(CasADi::MX* obj);+CasADi::MX* CasADi__MX__getDep_TIC(CasADi::MX* obj){++ return new CasADi::MX( obj->getDep() );+}+++// ================== Normal method: "getNumOutputs" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::getNumOutputs"+// cWrapperName: "CasADi__MX__getNumOutputs"+// protoArgs: "(CasADi::MX* obj)"+// args: "()"+// rettype: Val (NonVec CInt)+// cWrapperRetType: "int"+// proto: "int CasADi__MX__getNumOutputs(CasADi::MX* obj)"+// call: "obj->getNumOutputs()"+extern "C"+ int CasADi__MX__getNumOutputs(CasADi::MX* obj);+int CasADi__MX__getNumOutputs(CasADi::MX* obj){++ return obj->getNumOutputs();+}+++// ================== Normal method: "getOutput" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::getOutput"+// cWrapperName: "CasADi__MX__getOutput"+// protoArgs: "(CasADi::MX* obj, int x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass MX))+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__MX__getOutput(CasADi::MX* obj, int x0)"+// call: "obj->getOutput(x0_)"+extern "C"+ CasADi::MX* CasADi__MX__getOutput(CasADi::MX* obj, int x0);+CasADi::MX* CasADi__MX__getOutput(CasADi::MX* obj, int x0){+ int x0_ = Marshaling<int,int>::marshal(x0);++ return new CasADi::MX( obj->getOutput(x0_) );+}+++// ================== Normal method: "getOutput'" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::getOutput'"+// cWrapperName: "CasADi__MX__getOutput_TIC"+// protoArgs: "(CasADi::MX* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass MX))+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__MX__getOutput_TIC(CasADi::MX* obj)"+// call: "obj->getOutput()"+extern "C"+ CasADi::MX* CasADi__MX__getOutput_TIC(CasADi::MX* obj);+CasADi::MX* CasADi__MX__getOutput_TIC(CasADi::MX* obj){++ return new CasADi::MX( obj->getOutput() );+}+++// ================== Normal method: "getNdeps" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::getNdeps"+// cWrapperName: "CasADi__MX__getNdeps"+// protoArgs: "(CasADi::MX* obj)"+// args: "()"+// rettype: Val (NonVec CInt)+// cWrapperRetType: "int"+// proto: "int CasADi__MX__getNdeps(CasADi::MX* obj)"+// call: "obj->getNdeps()"+extern "C"+ int CasADi__MX__getNdeps(CasADi::MX* obj);+int CasADi__MX__getNdeps(CasADi::MX* obj){++ return obj->getNdeps();+}+++// ================== Normal method: "getName" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::getName"+// cWrapperName: "CasADi__MX__getName"+// protoArgs: "(CasADi::MX* obj)"+// args: "()"+// rettype: Val (NonVec StdString)+// cWrapperRetType: "std::string*"+// proto: "std::string* CasADi__MX__getName(CasADi::MX* obj)"+// call: "obj->getName()"+extern "C"+ std::string* CasADi__MX__getName(CasADi::MX* obj);+std::string* CasADi__MX__getName(CasADi::MX* obj){++ return new std::string( obj->getName() );+}+++// ================== Normal method: "getValue" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::getValue"+// cWrapperName: "CasADi__MX__getValue"+// protoArgs: "(CasADi::MX* obj)"+// args: "()"+// rettype: Val (NonVec CDouble)+// cWrapperRetType: "double"+// proto: "double CasADi__MX__getValue(CasADi::MX* obj)"+// call: "obj->getValue()"+extern "C"+ double CasADi__MX__getValue(CasADi::MX* obj);+double CasADi__MX__getValue(CasADi::MX* obj){++ return obj->getValue();+}+++// ================== Normal method: "getMatrixValue" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::getMatrixValue"+// cWrapperName: "CasADi__MX__getMatrixValue"+// protoArgs: "(CasADi::MX* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass DMatrix))+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__MX__getMatrixValue(CasADi::MX* obj)"+// call: "obj->getMatrixValue()"+extern "C"+ CasADi::Matrix< double >* CasADi__MX__getMatrixValue(CasADi::MX* obj);+CasADi::Matrix< double >* CasADi__MX__getMatrixValue(CasADi::MX* obj){++ return new CasADi::Matrix< double >( obj->getMatrixValue() );+}+++// ================== Normal method: "isSymbolic" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::isSymbolic"+// cWrapperName: "CasADi__MX__isSymbolic"+// protoArgs: "(CasADi::MX* obj)"+// args: "()"+// rettype: Val (NonVec CBool)+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__MX__isSymbolic(CasADi::MX* obj)"+// call: "obj->isSymbolic()"+extern "C"+ bool* CasADi__MX__isSymbolic(CasADi::MX* obj);+bool* CasADi__MX__isSymbolic(CasADi::MX* obj){++ return new bool( obj->isSymbolic() );+}+++// ================== Normal method: "isConstant" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::isConstant"+// cWrapperName: "CasADi__MX__isConstant"+// protoArgs: "(CasADi::MX* obj)"+// args: "()"+// rettype: Val (NonVec CBool)+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__MX__isConstant(CasADi::MX* obj)"+// call: "obj->isConstant()"+extern "C"+ bool* CasADi__MX__isConstant(CasADi::MX* obj);+bool* CasADi__MX__isConstant(CasADi::MX* obj){++ return new bool( obj->isConstant() );+}+++// ================== Normal method: "isEvaluation" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::isEvaluation"+// cWrapperName: "CasADi__MX__isEvaluation"+// protoArgs: "(CasADi::MX* obj)"+// args: "()"+// rettype: Val (NonVec CBool)+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__MX__isEvaluation(CasADi::MX* obj)"+// call: "obj->isEvaluation()"+extern "C"+ bool* CasADi__MX__isEvaluation(CasADi::MX* obj);+bool* CasADi__MX__isEvaluation(CasADi::MX* obj){++ return new bool( obj->isEvaluation() );+}+++// ================== Normal method: "isEvaluationOutput" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::isEvaluationOutput"+// cWrapperName: "CasADi__MX__isEvaluationOutput"+// protoArgs: "(CasADi::MX* obj)"+// args: "()"+// rettype: Val (NonVec CBool)+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__MX__isEvaluationOutput(CasADi::MX* obj)"+// call: "obj->isEvaluationOutput()"+extern "C"+ bool* CasADi__MX__isEvaluationOutput(CasADi::MX* obj);+bool* CasADi__MX__isEvaluationOutput(CasADi::MX* obj){++ return new bool( obj->isEvaluationOutput() );+}+++// ================== Normal method: "getEvaluationOutput" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::getEvaluationOutput"+// cWrapperName: "CasADi__MX__getEvaluationOutput"+// protoArgs: "(CasADi::MX* obj)"+// args: "()"+// rettype: Val (NonVec CInt)+// cWrapperRetType: "int"+// proto: "int CasADi__MX__getEvaluationOutput(CasADi::MX* obj)"+// call: "obj->getEvaluationOutput()"+extern "C"+ int CasADi__MX__getEvaluationOutput(CasADi::MX* obj);+int CasADi__MX__getEvaluationOutput(CasADi::MX* obj){++ return obj->getEvaluationOutput();+}+++// ================== Normal method: "isOperation" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::isOperation"+// cWrapperName: "CasADi__MX__isOperation"+// protoArgs: "(CasADi::MX* obj, int x0)"+// args: "(x0_)"+// rettype: Val (NonVec CBool)+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__MX__isOperation(CasADi::MX* obj, int x0)"+// call: "obj->isOperation(x0_)"+extern "C"+ bool* CasADi__MX__isOperation(CasADi::MX* obj, int x0);+bool* CasADi__MX__isOperation(CasADi::MX* obj, int x0){+ int x0_ = Marshaling<int,int>::marshal(x0);++ return new bool( obj->isOperation(x0_) );+}+++// ================== Normal method: "isMultiplication" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::isMultiplication"+// cWrapperName: "CasADi__MX__isMultiplication"+// protoArgs: "(CasADi::MX* obj)"+// args: "()"+// rettype: Val (NonVec CBool)+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__MX__isMultiplication(CasADi::MX* obj)"+// call: "obj->isMultiplication()"+extern "C"+ bool* CasADi__MX__isMultiplication(CasADi::MX* obj);+bool* CasADi__MX__isMultiplication(CasADi::MX* obj){++ return new bool( obj->isMultiplication() );+}+++// ================== Normal method: "isCommutative" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::isCommutative"+// cWrapperName: "CasADi__MX__isCommutative"+// protoArgs: "(CasADi::MX* obj)"+// args: "()"+// rettype: Val (NonVec CBool)+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__MX__isCommutative(CasADi::MX* obj)"+// call: "obj->isCommutative()"+extern "C"+ bool* CasADi__MX__isCommutative(CasADi::MX* obj);+bool* CasADi__MX__isCommutative(CasADi::MX* obj){++ return new bool( obj->isCommutative() );+}+++// ================== Normal method: "isNorm" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::isNorm"+// cWrapperName: "CasADi__MX__isNorm"+// protoArgs: "(CasADi::MX* obj)"+// args: "()"+// rettype: Val (NonVec CBool)+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__MX__isNorm(CasADi::MX* obj)"+// call: "obj->isNorm()"+extern "C"+ bool* CasADi__MX__isNorm(CasADi::MX* obj);+bool* CasADi__MX__isNorm(CasADi::MX* obj){++ return new bool( obj->isNorm() );+}+++// ================== Normal method: "getFunction" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::getFunction"+// cWrapperName: "CasADi__MX__getFunction"+// protoArgs: "(CasADi::MX* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass FX))+// cWrapperRetType: "CasADi::FX*"+// proto: "CasADi::FX* CasADi__MX__getFunction(CasADi::MX* obj)"+// call: "obj->getFunction()"+extern "C"+ CasADi::FX* CasADi__MX__getFunction(CasADi::MX* obj);+CasADi::FX* CasADi__MX__getFunction(CasADi::MX* obj){++ return new CasADi::FX( obj->getFunction() );+}+++// ================== Normal method: "isBinary" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::isBinary"+// cWrapperName: "CasADi__MX__isBinary"+// protoArgs: "(CasADi::MX* obj)"+// args: "()"+// rettype: Val (NonVec CBool)+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__MX__isBinary(CasADi::MX* obj)"+// call: "obj->isBinary()"+extern "C"+ bool* CasADi__MX__isBinary(CasADi::MX* obj);+bool* CasADi__MX__isBinary(CasADi::MX* obj){++ return new bool( obj->isBinary() );+}+++// ================== Normal method: "isUnary" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::isUnary"+// cWrapperName: "CasADi__MX__isUnary"+// protoArgs: "(CasADi::MX* obj)"+// args: "()"+// rettype: Val (NonVec CBool)+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__MX__isUnary(CasADi::MX* obj)"+// call: "obj->isUnary()"+extern "C"+ bool* CasADi__MX__isUnary(CasADi::MX* obj);+bool* CasADi__MX__isUnary(CasADi::MX* obj){++ return new bool( obj->isUnary() );+}+++// ================== Normal method: "getOp" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::getOp"+// cWrapperName: "CasADi__MX__getOp"+// protoArgs: "(CasADi::MX* obj)"+// args: "()"+// rettype: Val (NonVec CInt)+// cWrapperRetType: "int"+// proto: "int CasADi__MX__getOp(CasADi::MX* obj)"+// call: "obj->getOp()"+extern "C"+ int CasADi__MX__getOp(CasADi::MX* obj);+int CasADi__MX__getOp(CasADi::MX* obj){++ return obj->getOp();+}+++// ================== Normal method: "isEqual" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::isEqual"+// cWrapperName: "CasADi__MX__isEqual"+// protoArgs: "(CasADi::MX* obj, CasADi::MX* x0, int x1)"+// args: "(x0_, x1_)"+// rettype: Val (NonVec CBool)+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__MX__isEqual(CasADi::MX* obj, CasADi::MX* x0, int x1)"+// call: "obj->isEqual(x0_, x1_)"+extern "C"+ bool* CasADi__MX__isEqual(CasADi::MX* obj, CasADi::MX* x0, int x1);+bool* CasADi__MX__isEqual(CasADi::MX* obj, CasADi::MX* x0, int x1){+ CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);++ return new bool( obj->isEqual(x0_, x1_) );+}+++// ================== Normal method: "isEqual'" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::isEqual'"+// cWrapperName: "CasADi__MX__isEqual_TIC"+// protoArgs: "(CasADi::MX* obj, CasADi::MX* x0)"+// args: "(x0_)"+// rettype: Val (NonVec CBool)+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__MX__isEqual_TIC(CasADi::MX* obj, CasADi::MX* x0)"+// call: "obj->isEqual(x0_)"+extern "C"+ bool* CasADi__MX__isEqual_TIC(CasADi::MX* obj, CasADi::MX* x0);+bool* CasADi__MX__isEqual_TIC(CasADi::MX* obj, CasADi::MX* x0){+ CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);++ return new bool( obj->isEqual(x0_) );+}+++// ================== Normal method: "__hash__" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::__hash__"+// cWrapperName: "CasADi__MX____hash__"+// protoArgs: "(CasADi::MX* obj)"+// args: "()"+// rettype: Val (NonVec CLong)+// cWrapperRetType: "long"+// proto: "long CasADi__MX____hash__(CasADi::MX* obj)"+// call: "obj->__hash__()"+extern "C"+ long CasADi__MX____hash__(CasADi::MX* obj);+long CasADi__MX____hash__(CasADi::MX* obj){++ return obj->__hash__();+}+++// ================== Normal method: "getTemp" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::getTemp"+// cWrapperName: "CasADi__MX__getTemp"+// protoArgs: "(CasADi::MX* obj)"+// args: "()"+// rettype: Val (NonVec CInt)+// cWrapperRetType: "int"+// proto: "int CasADi__MX__getTemp(CasADi::MX* obj)"+// call: "obj->getTemp()"+extern "C"+ int CasADi__MX__getTemp(CasADi::MX* obj);+int CasADi__MX__getTemp(CasADi::MX* obj){++ return obj->getTemp();+}+++// ================== Normal method: "setTemp" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::setTemp"+// cWrapperName: "CasADi__MX__setTemp"+// protoArgs: "(CasADi::MX* obj, int x0)"+// args: "(x0_)"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__MX__setTemp(CasADi::MX* obj, int x0)"+// call: "obj->setTemp(x0_)"+extern "C"+ void CasADi__MX__setTemp(CasADi::MX* obj, int x0);+void CasADi__MX__setTemp(CasADi::MX* obj, int x0){+ int x0_ = Marshaling<int,int>::marshal(x0);++ return obj->setTemp(x0_);+}+++// ================== Static method: "binary" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::binary"+// cWrapperName: "CasADi__MX__binary"+// protoArgs: "(int x0, CasADi::MX* x1, CasADi::MX* x2)"+// args: "(x0_, x1_, x2_)"+// rettype: Val (NonVec (CasadiClass MX))+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__MX__binary(int x0, CasADi::MX* x1, CasADi::MX* x2)"+// call: "CasADi::MX::binary(x0_, x1_, x2_)"+extern "C"+ CasADi::MX* CasADi__MX__binary(int x0, CasADi::MX* x1, CasADi::MX* x2);+CasADi::MX* CasADi__MX__binary(int x0, CasADi::MX* x1, CasADi::MX* x2){+ int x0_ = Marshaling<int,int>::marshal(x0);+ CasADi::MX x1_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x1);+ CasADi::MX x2_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x2);++ return new CasADi::MX( CasADi::MX::binary(x0_, x1_, x2_) );+}+++// ================== Static method: "unary" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::unary"+// cWrapperName: "CasADi__MX__unary"+// protoArgs: "(int x0, CasADi::MX* x1)"+// args: "(x0_, x1_)"+// rettype: Val (NonVec (CasadiClass MX))+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__MX__unary(int x0, CasADi::MX* x1)"+// call: "CasADi::MX::unary(x0_, x1_)"+extern "C"+ CasADi::MX* CasADi__MX__unary(int x0, CasADi::MX* x1);+CasADi::MX* CasADi__MX__unary(int x0, CasADi::MX* x1){+ int x0_ = Marshaling<int,int>::marshal(x0);+ CasADi::MX x1_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x1);++ return new CasADi::MX( CasADi::MX::unary(x0_, x1_) );+}+++// ================== Static method: "sparse" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::sparse"+// cWrapperName: "CasADi__MX__sparse"+// protoArgs: "(int x0, int x1)"+// args: "(x0_, x1_)"+// rettype: Val (NonVec (CasadiClass MX))+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__MX__sparse(int x0, int x1)"+// call: "CasADi::MX::sparse(x0_, x1_)"+extern "C"+ CasADi::MX* CasADi__MX__sparse(int x0, int x1);+CasADi::MX* CasADi__MX__sparse(int x0, int x1){+ int x0_ = Marshaling<int,int>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);++ return new CasADi::MX( CasADi::MX::sparse(x0_, x1_) );+}+++// ================== Static method: "sparse'" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::sparse'"+// cWrapperName: "CasADi__MX__sparse_TIC"+// protoArgs: "(int x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass MX))+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__MX__sparse_TIC(int x0)"+// call: "CasADi::MX::sparse(x0_)"+extern "C"+ CasADi::MX* CasADi__MX__sparse_TIC(int x0);+CasADi::MX* CasADi__MX__sparse_TIC(int x0){+ int x0_ = Marshaling<int,int>::marshal(x0);++ return new CasADi::MX( CasADi::MX::sparse(x0_) );+}+++// ================== Static method: "zeros" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::zeros"+// cWrapperName: "CasADi__MX__zeros"+// protoArgs: "(CasADi::CRSSparsity* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass MX))+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__MX__zeros(CasADi::CRSSparsity* x0)"+// call: "CasADi::MX::zeros(x0_)"+extern "C"+ CasADi::MX* CasADi__MX__zeros(CasADi::CRSSparsity* x0);+CasADi::MX* CasADi__MX__zeros(CasADi::CRSSparsity* x0){+ CasADi::CRSSparsity x0_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x0);++ return new CasADi::MX( CasADi::MX::zeros(x0_) );+}+++// ================== Static method: "zeros'" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::zeros'"+// cWrapperName: "CasADi__MX__zeros_TIC"+// protoArgs: "(int x0, int x1)"+// args: "(x0_, x1_)"+// rettype: Val (NonVec (CasadiClass MX))+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__MX__zeros_TIC(int x0, int x1)"+// call: "CasADi::MX::zeros(x0_, x1_)"+extern "C"+ CasADi::MX* CasADi__MX__zeros_TIC(int x0, int x1);+CasADi::MX* CasADi__MX__zeros_TIC(int x0, int x1){+ int x0_ = Marshaling<int,int>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);++ return new CasADi::MX( CasADi::MX::zeros(x0_, x1_) );+}+++// ================== Static method: "zeros''" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::zeros''"+// cWrapperName: "CasADi__MX__zeros_TIC_TIC"+// protoArgs: "(int x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass MX))+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__MX__zeros_TIC_TIC(int x0)"+// call: "CasADi::MX::zeros(x0_)"+extern "C"+ CasADi::MX* CasADi__MX__zeros_TIC_TIC(int x0);+CasADi::MX* CasADi__MX__zeros_TIC_TIC(int x0){+ int x0_ = Marshaling<int,int>::marshal(x0);++ return new CasADi::MX( CasADi::MX::zeros(x0_) );+}+++// ================== Static method: "ones" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::ones"+// cWrapperName: "CasADi__MX__ones"+// protoArgs: "(CasADi::CRSSparsity* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass MX))+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__MX__ones(CasADi::CRSSparsity* x0)"+// call: "CasADi::MX::ones(x0_)"+extern "C"+ CasADi::MX* CasADi__MX__ones(CasADi::CRSSparsity* x0);+CasADi::MX* CasADi__MX__ones(CasADi::CRSSparsity* x0){+ CasADi::CRSSparsity x0_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x0);++ return new CasADi::MX( CasADi::MX::ones(x0_) );+}+++// ================== Static method: "ones'" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::ones'"+// cWrapperName: "CasADi__MX__ones_TIC"+// protoArgs: "(int x0, int x1)"+// args: "(x0_, x1_)"+// rettype: Val (NonVec (CasadiClass MX))+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__MX__ones_TIC(int x0, int x1)"+// call: "CasADi::MX::ones(x0_, x1_)"+extern "C"+ CasADi::MX* CasADi__MX__ones_TIC(int x0, int x1);+CasADi::MX* CasADi__MX__ones_TIC(int x0, int x1){+ int x0_ = Marshaling<int,int>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);++ return new CasADi::MX( CasADi::MX::ones(x0_, x1_) );+}+++// ================== Static method: "ones''" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::ones''"+// cWrapperName: "CasADi__MX__ones_TIC_TIC"+// protoArgs: "(int x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass MX))+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__MX__ones_TIC_TIC(int x0)"+// call: "CasADi::MX::ones(x0_)"+extern "C"+ CasADi::MX* CasADi__MX__ones_TIC_TIC(int x0);+CasADi::MX* CasADi__MX__ones_TIC_TIC(int x0){+ int x0_ = Marshaling<int,int>::marshal(x0);++ return new CasADi::MX( CasADi::MX::ones(x0_) );+}+++// ================== Static method: "inf" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::inf"+// cWrapperName: "CasADi__MX__inf"+// protoArgs: "(CasADi::CRSSparsity* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass MX))+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__MX__inf(CasADi::CRSSparsity* x0)"+// call: "CasADi::MX::inf(x0_)"+extern "C"+ CasADi::MX* CasADi__MX__inf(CasADi::CRSSparsity* x0);+CasADi::MX* CasADi__MX__inf(CasADi::CRSSparsity* x0){+ CasADi::CRSSparsity x0_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x0);++ return new CasADi::MX( CasADi::MX::inf(x0_) );+}+++// ================== Static method: "inf'" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::inf'"+// cWrapperName: "CasADi__MX__inf_TIC"+// protoArgs: "(int x0, int x1)"+// args: "(x0_, x1_)"+// rettype: Val (NonVec (CasadiClass MX))+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__MX__inf_TIC(int x0, int x1)"+// call: "CasADi::MX::inf(x0_, x1_)"+extern "C"+ CasADi::MX* CasADi__MX__inf_TIC(int x0, int x1);+CasADi::MX* CasADi__MX__inf_TIC(int x0, int x1){+ int x0_ = Marshaling<int,int>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);++ return new CasADi::MX( CasADi::MX::inf(x0_, x1_) );+}+++// ================== Static method: "inf''" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::inf''"+// cWrapperName: "CasADi__MX__inf_TIC_TIC"+// protoArgs: "(int x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass MX))+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__MX__inf_TIC_TIC(int x0)"+// call: "CasADi::MX::inf(x0_)"+extern "C"+ CasADi::MX* CasADi__MX__inf_TIC_TIC(int x0);+CasADi::MX* CasADi__MX__inf_TIC_TIC(int x0){+ int x0_ = Marshaling<int,int>::marshal(x0);++ return new CasADi::MX( CasADi::MX::inf(x0_) );+}+++// ================== Static method: "inf'''" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::inf'''"+// cWrapperName: "CasADi__MX__inf_TIC_TIC_TIC"+// protoArgs: "()"+// args: "()"+// rettype: Val (NonVec (CasadiClass MX))+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__MX__inf_TIC_TIC_TIC()"+// call: "CasADi::MX::inf()"+extern "C"+ CasADi::MX* CasADi__MX__inf_TIC_TIC_TIC();+CasADi::MX* CasADi__MX__inf_TIC_TIC_TIC(){++ return new CasADi::MX( CasADi::MX::inf() );+}+++// ================== Static method: "nan" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::nan"+// cWrapperName: "CasADi__MX__nan"+// protoArgs: "(CasADi::CRSSparsity* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass MX))+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__MX__nan(CasADi::CRSSparsity* x0)"+// call: "CasADi::MX::nan(x0_)"+extern "C"+ CasADi::MX* CasADi__MX__nan(CasADi::CRSSparsity* x0);+CasADi::MX* CasADi__MX__nan(CasADi::CRSSparsity* x0){+ CasADi::CRSSparsity x0_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x0);++ return new CasADi::MX( CasADi::MX::nan(x0_) );+}+++// ================== Static method: "nan'" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::nan'"+// cWrapperName: "CasADi__MX__nan_TIC"+// protoArgs: "(int x0, int x1)"+// args: "(x0_, x1_)"+// rettype: Val (NonVec (CasadiClass MX))+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__MX__nan_TIC(int x0, int x1)"+// call: "CasADi::MX::nan(x0_, x1_)"+extern "C"+ CasADi::MX* CasADi__MX__nan_TIC(int x0, int x1);+CasADi::MX* CasADi__MX__nan_TIC(int x0, int x1){+ int x0_ = Marshaling<int,int>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);++ return new CasADi::MX( CasADi::MX::nan(x0_, x1_) );+}+++// ================== Static method: "nan''" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::nan''"+// cWrapperName: "CasADi__MX__nan_TIC_TIC"+// protoArgs: "(int x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass MX))+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__MX__nan_TIC_TIC(int x0)"+// call: "CasADi::MX::nan(x0_)"+extern "C"+ CasADi::MX* CasADi__MX__nan_TIC_TIC(int x0);+CasADi::MX* CasADi__MX__nan_TIC_TIC(int x0){+ int x0_ = Marshaling<int,int>::marshal(x0);++ return new CasADi::MX( CasADi::MX::nan(x0_) );+}+++// ================== Static method: "nan'''" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::nan'''"+// cWrapperName: "CasADi__MX__nan_TIC_TIC_TIC"+// protoArgs: "()"+// args: "()"+// rettype: Val (NonVec (CasadiClass MX))+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__MX__nan_TIC_TIC_TIC()"+// call: "CasADi::MX::nan()"+extern "C"+ CasADi::MX* CasADi__MX__nan_TIC_TIC_TIC();+CasADi::MX* CasADi__MX__nan_TIC_TIC_TIC(){++ return new CasADi::MX( CasADi::MX::nan() );+}+++// ================== Static method: "repmat" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::repmat"+// cWrapperName: "CasADi__MX__repmat"+// protoArgs: "(CasADi::MX* x0, int x1, int x2)"+// args: "(x0_, x1_, x2_)"+// rettype: Val (NonVec (CasadiClass MX))+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__MX__repmat(CasADi::MX* x0, int x1, int x2)"+// call: "CasADi::MX::repmat(x0_, x1_, x2_)"+extern "C"+ CasADi::MX* CasADi__MX__repmat(CasADi::MX* x0, int x1, int x2);+CasADi::MX* CasADi__MX__repmat(CasADi::MX* x0, int x1, int x2){+ CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);+ int x2_ = Marshaling<int,int>::marshal(x2);++ return new CasADi::MX( CasADi::MX::repmat(x0_, x1_, x2_) );+}+++// ================== Static method: "repmat'" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::repmat'"+// cWrapperName: "CasADi__MX__repmat_TIC"+// protoArgs: "(CasADi::MX* x0, int x1)"+// args: "(x0_, x1_)"+// rettype: Val (NonVec (CasadiClass MX))+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__MX__repmat_TIC(CasADi::MX* x0, int x1)"+// call: "CasADi::MX::repmat(x0_, x1_)"+extern "C"+ CasADi::MX* CasADi__MX__repmat_TIC(CasADi::MX* x0, int x1);+CasADi::MX* CasADi__MX__repmat_TIC(CasADi::MX* x0, int x1){+ CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);++ return new CasADi::MX( CasADi::MX::repmat(x0_, x1_) );+}+++// ================== Static method: "eye" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::eye"+// cWrapperName: "CasADi__MX__eye"+// protoArgs: "(int x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass MX))+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__MX__eye(int x0)"+// call: "CasADi::MX::eye(x0_)"+extern "C"+ CasADi::MX* CasADi__MX__eye(int x0);+CasADi::MX* CasADi__MX__eye(int x0){+ int x0_ = Marshaling<int,int>::marshal(x0);++ return new CasADi::MX( CasADi::MX::eye(x0_) );+}+++// ================== Normal method: "getNZ" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::getNZ"+// cWrapperName: "CasADi__MX__getNZ"+// protoArgs: "(CasADi::MX* obj, int x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass MX))+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__MX__getNZ(CasADi::MX* obj, int x0)"+// call: "obj->getNZ(x0_)"+extern "C"+ CasADi::MX* CasADi__MX__getNZ(CasADi::MX* obj, int x0);+CasADi::MX* CasADi__MX__getNZ(CasADi::MX* obj, int x0){+ int x0_ = Marshaling<int,int>::marshal(x0);++ return new CasADi::MX( obj->getNZ(x0_) );+}+++// ================== Normal method: "getNZ'" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::getNZ'"+// cWrapperName: "CasADi__MX__getNZ_TIC"+// protoArgs: "(CasADi::MX* obj, std::vector<int > * x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass MX))+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__MX__getNZ_TIC(CasADi::MX* obj, std::vector<int > * x0)"+// call: "obj->getNZ(x0_)"+extern "C"+ CasADi::MX* CasADi__MX__getNZ_TIC(CasADi::MX* obj, std::vector<int > * x0);+CasADi::MX* CasADi__MX__getNZ_TIC(CasADi::MX* obj, std::vector<int > * x0){+ std::vector<int > x0_ = Marshaling<std::vector<int >,std::vector<int > *>::marshal(x0);++ return new CasADi::MX( obj->getNZ(x0_) );+}+++// ================== Normal method: "append" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::append"+// cWrapperName: "CasADi__MX__append"+// protoArgs: "(CasADi::MX* obj, CasADi::MX* x0)"+// args: "(x0_)"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__MX__append(CasADi::MX* obj, CasADi::MX* x0)"+// call: "obj->append(x0_)"+extern "C"+ void CasADi__MX__append(CasADi::MX* obj, CasADi::MX* x0);+void CasADi__MX__append(CasADi::MX* obj, CasADi::MX* x0){+ CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);++ return obj->append(x0_);+}+++// ================== Normal method: "__add__" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::__add__"+// cWrapperName: "CasADi__MX____add__"+// protoArgs: "(CasADi::MX* obj, CasADi::MX* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass MX))+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__MX____add__(CasADi::MX* obj, CasADi::MX* x0)"+// call: "obj->__add__(x0_)"+extern "C"+ CasADi::MX* CasADi__MX____add__(CasADi::MX* obj, CasADi::MX* x0);+CasADi::MX* CasADi__MX____add__(CasADi::MX* obj, CasADi::MX* x0){+ CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);++ return new CasADi::MX( obj->__add__(x0_) );+}+++// ================== Normal method: "__sub__" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::__sub__"+// cWrapperName: "CasADi__MX____sub__"+// protoArgs: "(CasADi::MX* obj, CasADi::MX* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass MX))+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__MX____sub__(CasADi::MX* obj, CasADi::MX* x0)"+// call: "obj->__sub__(x0_)"+extern "C"+ CasADi::MX* CasADi__MX____sub__(CasADi::MX* obj, CasADi::MX* x0);+CasADi::MX* CasADi__MX____sub__(CasADi::MX* obj, CasADi::MX* x0){+ CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);++ return new CasADi::MX( obj->__sub__(x0_) );+}+++// ================== Normal method: "__mul__" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::__mul__"+// cWrapperName: "CasADi__MX____mul__"+// protoArgs: "(CasADi::MX* obj, CasADi::MX* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass MX))+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__MX____mul__(CasADi::MX* obj, CasADi::MX* x0)"+// call: "obj->__mul__(x0_)"+extern "C"+ CasADi::MX* CasADi__MX____mul__(CasADi::MX* obj, CasADi::MX* x0);+CasADi::MX* CasADi__MX____mul__(CasADi::MX* obj, CasADi::MX* x0){+ CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);++ return new CasADi::MX( obj->__mul__(x0_) );+}+++// ================== Normal method: "__div__" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::__div__"+// cWrapperName: "CasADi__MX____div__"+// protoArgs: "(CasADi::MX* obj, CasADi::MX* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass MX))+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__MX____div__(CasADi::MX* obj, CasADi::MX* x0)"+// call: "obj->__div__(x0_)"+extern "C"+ CasADi::MX* CasADi__MX____div__(CasADi::MX* obj, CasADi::MX* x0);+CasADi::MX* CasADi__MX____div__(CasADi::MX* obj, CasADi::MX* x0){+ CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);++ return new CasADi::MX( obj->__div__(x0_) );+}+++// ================== Normal method: "__lt__" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::__lt__"+// cWrapperName: "CasADi__MX____lt__"+// protoArgs: "(CasADi::MX* obj, CasADi::MX* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass MX))+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__MX____lt__(CasADi::MX* obj, CasADi::MX* x0)"+// call: "obj->__lt__(x0_)"+extern "C"+ CasADi::MX* CasADi__MX____lt__(CasADi::MX* obj, CasADi::MX* x0);+CasADi::MX* CasADi__MX____lt__(CasADi::MX* obj, CasADi::MX* x0){+ CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);++ return new CasADi::MX( obj->__lt__(x0_) );+}+++// ================== Normal method: "__le__" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::__le__"+// cWrapperName: "CasADi__MX____le__"+// protoArgs: "(CasADi::MX* obj, CasADi::MX* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass MX))+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__MX____le__(CasADi::MX* obj, CasADi::MX* x0)"+// call: "obj->__le__(x0_)"+extern "C"+ CasADi::MX* CasADi__MX____le__(CasADi::MX* obj, CasADi::MX* x0);+CasADi::MX* CasADi__MX____le__(CasADi::MX* obj, CasADi::MX* x0){+ CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);++ return new CasADi::MX( obj->__le__(x0_) );+}+++// ================== Normal method: "__eq__" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::__eq__"+// cWrapperName: "CasADi__MX____eq__"+// protoArgs: "(CasADi::MX* obj, CasADi::MX* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass MX))+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__MX____eq__(CasADi::MX* obj, CasADi::MX* x0)"+// call: "obj->__eq__(x0_)"+extern "C"+ CasADi::MX* CasADi__MX____eq__(CasADi::MX* obj, CasADi::MX* x0);+CasADi::MX* CasADi__MX____eq__(CasADi::MX* obj, CasADi::MX* x0){+ CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);++ return new CasADi::MX( obj->__eq__(x0_) );+}+++// ================== Normal method: "__ne__" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::__ne__"+// cWrapperName: "CasADi__MX____ne__"+// protoArgs: "(CasADi::MX* obj, CasADi::MX* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass MX))+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__MX____ne__(CasADi::MX* obj, CasADi::MX* x0)"+// call: "obj->__ne__(x0_)"+extern "C"+ CasADi::MX* CasADi__MX____ne__(CasADi::MX* obj, CasADi::MX* x0);+CasADi::MX* CasADi__MX____ne__(CasADi::MX* obj, CasADi::MX* x0){+ CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);++ return new CasADi::MX( obj->__ne__(x0_) );+}+++// ================== Normal method: "__truediv__" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::__truediv__"+// cWrapperName: "CasADi__MX____truediv__"+// protoArgs: "(CasADi::MX* obj, CasADi::MX* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass MX))+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__MX____truediv__(CasADi::MX* obj, CasADi::MX* x0)"+// call: "obj->__truediv__(x0_)"+extern "C"+ CasADi::MX* CasADi__MX____truediv__(CasADi::MX* obj, CasADi::MX* x0);+CasADi::MX* CasADi__MX____truediv__(CasADi::MX* obj, CasADi::MX* x0){+ CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);++ return new CasADi::MX( obj->__truediv__(x0_) );+}+++// ================== Normal method: "__pow__" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::__pow__"+// cWrapperName: "CasADi__MX____pow__"+// protoArgs: "(CasADi::MX* obj, CasADi::MX* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass MX))+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__MX____pow__(CasADi::MX* obj, CasADi::MX* x0)"+// call: "obj->__pow__(x0_)"+extern "C"+ CasADi::MX* CasADi__MX____pow__(CasADi::MX* obj, CasADi::MX* x0);+CasADi::MX* CasADi__MX____pow__(CasADi::MX* obj, CasADi::MX* x0){+ CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);++ return new CasADi::MX( obj->__pow__(x0_) );+}+++// ================== Normal method: "__constpow__" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::__constpow__"+// cWrapperName: "CasADi__MX____constpow__"+// protoArgs: "(CasADi::MX* obj, CasADi::MX* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass MX))+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__MX____constpow__(CasADi::MX* obj, CasADi::MX* x0)"+// call: "obj->__constpow__(x0_)"+extern "C"+ CasADi::MX* CasADi__MX____constpow__(CasADi::MX* obj, CasADi::MX* x0);+CasADi::MX* CasADi__MX____constpow__(CasADi::MX* obj, CasADi::MX* x0){+ CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);++ return new CasADi::MX( obj->__constpow__(x0_) );+}+++// ================== Normal method: "__mrdivide__" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::__mrdivide__"+// cWrapperName: "CasADi__MX____mrdivide__"+// protoArgs: "(CasADi::MX* obj, CasADi::MX* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass MX))+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__MX____mrdivide__(CasADi::MX* obj, CasADi::MX* x0)"+// call: "obj->__mrdivide__(x0_)"+extern "C"+ CasADi::MX* CasADi__MX____mrdivide__(CasADi::MX* obj, CasADi::MX* x0);+CasADi::MX* CasADi__MX____mrdivide__(CasADi::MX* obj, CasADi::MX* x0){+ CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);++ return new CasADi::MX( obj->__mrdivide__(x0_) );+}+++// ================== Normal method: "__mpower__" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::__mpower__"+// cWrapperName: "CasADi__MX____mpower__"+// protoArgs: "(CasADi::MX* obj, CasADi::MX* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass MX))+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__MX____mpower__(CasADi::MX* obj, CasADi::MX* x0)"+// call: "obj->__mpower__(x0_)"+extern "C"+ CasADi::MX* CasADi__MX____mpower__(CasADi::MX* obj, CasADi::MX* x0);+CasADi::MX* CasADi__MX____mpower__(CasADi::MX* obj, CasADi::MX* x0){+ CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);++ return new CasADi::MX( obj->__mpower__(x0_) );+}+++// ================== Normal method: "mul" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::mul"+// cWrapperName: "CasADi__MX__mul"+// protoArgs: "(CasADi::MX* obj, CasADi::MX* x0, CasADi::CRSSparsity* x1)"+// args: "(x0_, x1_)"+// rettype: Val (NonVec (CasadiClass MX))+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__MX__mul(CasADi::MX* obj, CasADi::MX* x0, CasADi::CRSSparsity* x1)"+// call: "obj->mul(x0_, x1_)"+extern "C"+ CasADi::MX* CasADi__MX__mul(CasADi::MX* obj, CasADi::MX* x0, CasADi::CRSSparsity* x1);+CasADi::MX* CasADi__MX__mul(CasADi::MX* obj, CasADi::MX* x0, CasADi::CRSSparsity* x1){+ CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);+ CasADi::CRSSparsity x1_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x1);++ return new CasADi::MX( obj->mul(x0_, x1_) );+}+++// ================== Normal method: "mul'" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::mul'"+// cWrapperName: "CasADi__MX__mul_TIC"+// protoArgs: "(CasADi::MX* obj, CasADi::MX* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass MX))+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__MX__mul_TIC(CasADi::MX* obj, CasADi::MX* x0)"+// call: "obj->mul(x0_)"+extern "C"+ CasADi::MX* CasADi__MX__mul_TIC(CasADi::MX* obj, CasADi::MX* x0);+CasADi::MX* CasADi__MX__mul_TIC(CasADi::MX* obj, CasADi::MX* x0){+ CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);++ return new CasADi::MX( obj->mul(x0_) );+}+++// ================== Normal method: "mul_full" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::mul_full"+// cWrapperName: "CasADi__MX__mul_full"+// protoArgs: "(CasADi::MX* obj, CasADi::MX* x0, CasADi::CRSSparsity* x1)"+// args: "(x0_, x1_)"+// rettype: Val (NonVec (CasadiClass MX))+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__MX__mul_full(CasADi::MX* obj, CasADi::MX* x0, CasADi::CRSSparsity* x1)"+// call: "obj->mul_full(x0_, x1_)"+extern "C"+ CasADi::MX* CasADi__MX__mul_full(CasADi::MX* obj, CasADi::MX* x0, CasADi::CRSSparsity* x1);+CasADi::MX* CasADi__MX__mul_full(CasADi::MX* obj, CasADi::MX* x0, CasADi::CRSSparsity* x1){+ CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);+ CasADi::CRSSparsity x1_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x1);++ return new CasADi::MX( obj->mul_full(x0_, x1_) );+}+++// ================== Normal method: "mul_full'" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::mul_full'"+// cWrapperName: "CasADi__MX__mul_full_TIC"+// protoArgs: "(CasADi::MX* obj, CasADi::MX* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass MX))+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__MX__mul_full_TIC(CasADi::MX* obj, CasADi::MX* x0)"+// call: "obj->mul_full(x0_)"+extern "C"+ CasADi::MX* CasADi__MX__mul_full_TIC(CasADi::MX* obj, CasADi::MX* x0);+CasADi::MX* CasADi__MX__mul_full_TIC(CasADi::MX* obj, CasADi::MX* x0){+ CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);++ return new CasADi::MX( obj->mul_full(x0_) );+}+++// ================== Normal method: "inner_prod" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::inner_prod"+// cWrapperName: "CasADi__MX__inner_prod"+// protoArgs: "(CasADi::MX* obj, CasADi::MX* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass MX))+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__MX__inner_prod(CasADi::MX* obj, CasADi::MX* x0)"+// call: "obj->inner_prod(x0_)"+extern "C"+ CasADi::MX* CasADi__MX__inner_prod(CasADi::MX* obj, CasADi::MX* x0);+CasADi::MX* CasADi__MX__inner_prod(CasADi::MX* obj, CasADi::MX* x0){+ CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);++ return new CasADi::MX( obj->inner_prod(x0_) );+}+++// ================== Normal method: "outer_prod" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::outer_prod"+// cWrapperName: "CasADi__MX__outer_prod"+// protoArgs: "(CasADi::MX* obj, CasADi::MX* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass MX))+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__MX__outer_prod(CasADi::MX* obj, CasADi::MX* x0)"+// call: "obj->outer_prod(x0_)"+extern "C"+ CasADi::MX* CasADi__MX__outer_prod(CasADi::MX* obj, CasADi::MX* x0);+CasADi::MX* CasADi__MX__outer_prod(CasADi::MX* obj, CasADi::MX* x0){+ CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);++ return new CasADi::MX( obj->outer_prod(x0_) );+}+++// ================== Normal method: "constpow" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::constpow"+// cWrapperName: "CasADi__MX__constpow"+// protoArgs: "(CasADi::MX* obj, CasADi::MX* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass MX))+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__MX__constpow(CasADi::MX* obj, CasADi::MX* x0)"+// call: "obj->constpow(x0_)"+extern "C"+ CasADi::MX* CasADi__MX__constpow(CasADi::MX* obj, CasADi::MX* x0);+CasADi::MX* CasADi__MX__constpow(CasADi::MX* obj, CasADi::MX* x0){+ CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);++ return new CasADi::MX( obj->constpow(x0_) );+}+++// ================== Normal method: "fmin" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::fmin"+// cWrapperName: "CasADi__MX__fmin"+// protoArgs: "(CasADi::MX* obj, CasADi::MX* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass MX))+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__MX__fmin(CasADi::MX* obj, CasADi::MX* x0)"+// call: "obj->fmin(x0_)"+extern "C"+ CasADi::MX* CasADi__MX__fmin(CasADi::MX* obj, CasADi::MX* x0);+CasADi::MX* CasADi__MX__fmin(CasADi::MX* obj, CasADi::MX* x0){+ CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);++ return new CasADi::MX( obj->fmin(x0_) );+}+++// ================== Normal method: "fmax" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::fmax"+// cWrapperName: "CasADi__MX__fmax"+// protoArgs: "(CasADi::MX* obj, CasADi::MX* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass MX))+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__MX__fmax(CasADi::MX* obj, CasADi::MX* x0)"+// call: "obj->fmax(x0_)"+extern "C"+ CasADi::MX* CasADi__MX__fmax(CasADi::MX* obj, CasADi::MX* x0);+CasADi::MX* CasADi__MX__fmax(CasADi::MX* obj, CasADi::MX* x0){+ CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);++ return new CasADi::MX( obj->fmax(x0_) );+}+++// ================== Normal method: "printme" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::printme"+// cWrapperName: "CasADi__MX__printme"+// protoArgs: "(CasADi::MX* obj, CasADi::MX* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass MX))+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__MX__printme(CasADi::MX* obj, CasADi::MX* x0)"+// call: "obj->printme(x0_)"+extern "C"+ CasADi::MX* CasADi__MX__printme(CasADi::MX* obj, CasADi::MX* x0);+CasADi::MX* CasADi__MX__printme(CasADi::MX* obj, CasADi::MX* x0){+ CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);++ return new CasADi::MX( obj->printme(x0_) );+}+++// ================== Normal method: "arctan2" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::arctan2"+// cWrapperName: "CasADi__MX__arctan2"+// protoArgs: "(CasADi::MX* obj, CasADi::MX* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass MX))+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__MX__arctan2(CasADi::MX* obj, CasADi::MX* x0)"+// call: "obj->arctan2(x0_)"+extern "C"+ CasADi::MX* CasADi__MX__arctan2(CasADi::MX* obj, CasADi::MX* x0);+CasADi::MX* CasADi__MX__arctan2(CasADi::MX* obj, CasADi::MX* x0){+ CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);++ return new CasADi::MX( obj->arctan2(x0_) );+}+++// ================== Normal method: "logic_and" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::logic_and"+// cWrapperName: "CasADi__MX__logic_and"+// protoArgs: "(CasADi::MX* obj, CasADi::MX* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass MX))+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__MX__logic_and(CasADi::MX* obj, CasADi::MX* x0)"+// call: "obj->logic_and(x0_)"+extern "C"+ CasADi::MX* CasADi__MX__logic_and(CasADi::MX* obj, CasADi::MX* x0);+CasADi::MX* CasADi__MX__logic_and(CasADi::MX* obj, CasADi::MX* x0){+ CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);++ return new CasADi::MX( obj->logic_and(x0_) );+}+++// ================== Normal method: "logic_or" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::logic_or"+// cWrapperName: "CasADi__MX__logic_or"+// protoArgs: "(CasADi::MX* obj, CasADi::MX* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass MX))+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__MX__logic_or(CasADi::MX* obj, CasADi::MX* x0)"+// call: "obj->logic_or(x0_)"+extern "C"+ CasADi::MX* CasADi__MX__logic_or(CasADi::MX* obj, CasADi::MX* x0);+CasADi::MX* CasADi__MX__logic_or(CasADi::MX* obj, CasADi::MX* x0){+ CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);++ return new CasADi::MX( obj->logic_or(x0_) );+}+++// ================== Normal method: "if_else_zero" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::if_else_zero"+// cWrapperName: "CasADi__MX__if_else_zero"+// protoArgs: "(CasADi::MX* obj, CasADi::MX* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass MX))+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__MX__if_else_zero(CasADi::MX* obj, CasADi::MX* x0)"+// call: "obj->if_else_zero(x0_)"+extern "C"+ CasADi::MX* CasADi__MX__if_else_zero(CasADi::MX* obj, CasADi::MX* x0);+CasADi::MX* CasADi__MX__if_else_zero(CasADi::MX* obj, CasADi::MX* x0){+ CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);++ return new CasADi::MX( obj->if_else_zero(x0_) );+}+++// ================== Normal method: "exp" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::exp"+// cWrapperName: "CasADi__MX__exp"+// protoArgs: "(CasADi::MX* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass MX))+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__MX__exp(CasADi::MX* obj)"+// call: "obj->exp()"+extern "C"+ CasADi::MX* CasADi__MX__exp(CasADi::MX* obj);+CasADi::MX* CasADi__MX__exp(CasADi::MX* obj){++ return new CasADi::MX( obj->exp() );+}+++// ================== Normal method: "log" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::log"+// cWrapperName: "CasADi__MX__log"+// protoArgs: "(CasADi::MX* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass MX))+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__MX__log(CasADi::MX* obj)"+// call: "obj->log()"+extern "C"+ CasADi::MX* CasADi__MX__log(CasADi::MX* obj);+CasADi::MX* CasADi__MX__log(CasADi::MX* obj){++ return new CasADi::MX( obj->log() );+}+++// ================== Normal method: "log10" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::log10"+// cWrapperName: "CasADi__MX__log10"+// protoArgs: "(CasADi::MX* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass MX))+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__MX__log10(CasADi::MX* obj)"+// call: "obj->log10()"+extern "C"+ CasADi::MX* CasADi__MX__log10(CasADi::MX* obj);+CasADi::MX* CasADi__MX__log10(CasADi::MX* obj){++ return new CasADi::MX( obj->log10() );+}+++// ================== Normal method: "sqrt" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::sqrt"+// cWrapperName: "CasADi__MX__sqrt"+// protoArgs: "(CasADi::MX* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass MX))+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__MX__sqrt(CasADi::MX* obj)"+// call: "obj->sqrt()"+extern "C"+ CasADi::MX* CasADi__MX__sqrt(CasADi::MX* obj);+CasADi::MX* CasADi__MX__sqrt(CasADi::MX* obj){++ return new CasADi::MX( obj->sqrt() );+}+++// ================== Normal method: "sin" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::sin"+// cWrapperName: "CasADi__MX__sin"+// protoArgs: "(CasADi::MX* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass MX))+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__MX__sin(CasADi::MX* obj)"+// call: "obj->sin()"+extern "C"+ CasADi::MX* CasADi__MX__sin(CasADi::MX* obj);+CasADi::MX* CasADi__MX__sin(CasADi::MX* obj){++ return new CasADi::MX( obj->sin() );+}+++// ================== Normal method: "cos" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::cos"+// cWrapperName: "CasADi__MX__cos"+// protoArgs: "(CasADi::MX* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass MX))+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__MX__cos(CasADi::MX* obj)"+// call: "obj->cos()"+extern "C"+ CasADi::MX* CasADi__MX__cos(CasADi::MX* obj);+CasADi::MX* CasADi__MX__cos(CasADi::MX* obj){++ return new CasADi::MX( obj->cos() );+}+++// ================== Normal method: "tan" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::tan"+// cWrapperName: "CasADi__MX__tan"+// protoArgs: "(CasADi::MX* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass MX))+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__MX__tan(CasADi::MX* obj)"+// call: "obj->tan()"+extern "C"+ CasADi::MX* CasADi__MX__tan(CasADi::MX* obj);+CasADi::MX* CasADi__MX__tan(CasADi::MX* obj){++ return new CasADi::MX( obj->tan() );+}+++// ================== Normal method: "arcsin" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::arcsin"+// cWrapperName: "CasADi__MX__arcsin"+// protoArgs: "(CasADi::MX* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass MX))+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__MX__arcsin(CasADi::MX* obj)"+// call: "obj->arcsin()"+extern "C"+ CasADi::MX* CasADi__MX__arcsin(CasADi::MX* obj);+CasADi::MX* CasADi__MX__arcsin(CasADi::MX* obj){++ return new CasADi::MX( obj->arcsin() );+}+++// ================== Normal method: "arccos" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::arccos"+// cWrapperName: "CasADi__MX__arccos"+// protoArgs: "(CasADi::MX* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass MX))+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__MX__arccos(CasADi::MX* obj)"+// call: "obj->arccos()"+extern "C"+ CasADi::MX* CasADi__MX__arccos(CasADi::MX* obj);+CasADi::MX* CasADi__MX__arccos(CasADi::MX* obj){++ return new CasADi::MX( obj->arccos() );+}+++// ================== Normal method: "arctan" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::arctan"+// cWrapperName: "CasADi__MX__arctan"+// protoArgs: "(CasADi::MX* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass MX))+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__MX__arctan(CasADi::MX* obj)"+// call: "obj->arctan()"+extern "C"+ CasADi::MX* CasADi__MX__arctan(CasADi::MX* obj);+CasADi::MX* CasADi__MX__arctan(CasADi::MX* obj){++ return new CasADi::MX( obj->arctan() );+}+++// ================== Normal method: "floor" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::floor"+// cWrapperName: "CasADi__MX__floor"+// protoArgs: "(CasADi::MX* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass MX))+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__MX__floor(CasADi::MX* obj)"+// call: "obj->floor()"+extern "C"+ CasADi::MX* CasADi__MX__floor(CasADi::MX* obj);+CasADi::MX* CasADi__MX__floor(CasADi::MX* obj){++ return new CasADi::MX( obj->floor() );+}+++// ================== Normal method: "ceil" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::ceil"+// cWrapperName: "CasADi__MX__ceil"+// protoArgs: "(CasADi::MX* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass MX))+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__MX__ceil(CasADi::MX* obj)"+// call: "obj->ceil()"+extern "C"+ CasADi::MX* CasADi__MX__ceil(CasADi::MX* obj);+CasADi::MX* CasADi__MX__ceil(CasADi::MX* obj){++ return new CasADi::MX( obj->ceil() );+}+++// ================== Normal method: "fabs" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::fabs"+// cWrapperName: "CasADi__MX__fabs"+// protoArgs: "(CasADi::MX* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass MX))+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__MX__fabs(CasADi::MX* obj)"+// call: "obj->fabs()"+extern "C"+ CasADi::MX* CasADi__MX__fabs(CasADi::MX* obj);+CasADi::MX* CasADi__MX__fabs(CasADi::MX* obj){++ return new CasADi::MX( obj->fabs() );+}+++// ================== Normal method: "sign" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::sign"+// cWrapperName: "CasADi__MX__sign"+// protoArgs: "(CasADi::MX* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass MX))+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__MX__sign(CasADi::MX* obj)"+// call: "obj->sign()"+extern "C"+ CasADi::MX* CasADi__MX__sign(CasADi::MX* obj);+CasADi::MX* CasADi__MX__sign(CasADi::MX* obj){++ return new CasADi::MX( obj->sign() );+}+++// ================== Normal method: "erfinv" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::erfinv"+// cWrapperName: "CasADi__MX__erfinv"+// protoArgs: "(CasADi::MX* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass MX))+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__MX__erfinv(CasADi::MX* obj)"+// call: "obj->erfinv()"+extern "C"+ CasADi::MX* CasADi__MX__erfinv(CasADi::MX* obj);+CasADi::MX* CasADi__MX__erfinv(CasADi::MX* obj){++ return new CasADi::MX( obj->erfinv() );+}+++// ================== Normal method: "erf" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::erf"+// cWrapperName: "CasADi__MX__erf"+// protoArgs: "(CasADi::MX* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass MX))+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__MX__erf(CasADi::MX* obj)"+// call: "obj->erf()"+extern "C"+ CasADi::MX* CasADi__MX__erf(CasADi::MX* obj);+CasADi::MX* CasADi__MX__erf(CasADi::MX* obj){++ return new CasADi::MX( obj->erf() );+}+++// ================== Normal method: "sinh" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::sinh"+// cWrapperName: "CasADi__MX__sinh"+// protoArgs: "(CasADi::MX* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass MX))+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__MX__sinh(CasADi::MX* obj)"+// call: "obj->sinh()"+extern "C"+ CasADi::MX* CasADi__MX__sinh(CasADi::MX* obj);+CasADi::MX* CasADi__MX__sinh(CasADi::MX* obj){++ return new CasADi::MX( obj->sinh() );+}+++// ================== Normal method: "cosh" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::cosh"+// cWrapperName: "CasADi__MX__cosh"+// protoArgs: "(CasADi::MX* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass MX))+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__MX__cosh(CasADi::MX* obj)"+// call: "obj->cosh()"+extern "C"+ CasADi::MX* CasADi__MX__cosh(CasADi::MX* obj);+CasADi::MX* CasADi__MX__cosh(CasADi::MX* obj){++ return new CasADi::MX( obj->cosh() );+}+++// ================== Normal method: "tanh" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::tanh"+// cWrapperName: "CasADi__MX__tanh"+// protoArgs: "(CasADi::MX* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass MX))+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__MX__tanh(CasADi::MX* obj)"+// call: "obj->tanh()"+extern "C"+ CasADi::MX* CasADi__MX__tanh(CasADi::MX* obj);+CasADi::MX* CasADi__MX__tanh(CasADi::MX* obj){++ return new CasADi::MX( obj->tanh() );+}+++// ================== Normal method: "arcsinh" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::arcsinh"+// cWrapperName: "CasADi__MX__arcsinh"+// protoArgs: "(CasADi::MX* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass MX))+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__MX__arcsinh(CasADi::MX* obj)"+// call: "obj->arcsinh()"+extern "C"+ CasADi::MX* CasADi__MX__arcsinh(CasADi::MX* obj);+CasADi::MX* CasADi__MX__arcsinh(CasADi::MX* obj){++ return new CasADi::MX( obj->arcsinh() );+}+++// ================== Normal method: "arccosh" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::arccosh"+// cWrapperName: "CasADi__MX__arccosh"+// protoArgs: "(CasADi::MX* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass MX))+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__MX__arccosh(CasADi::MX* obj)"+// call: "obj->arccosh()"+extern "C"+ CasADi::MX* CasADi__MX__arccosh(CasADi::MX* obj);+CasADi::MX* CasADi__MX__arccosh(CasADi::MX* obj){++ return new CasADi::MX( obj->arccosh() );+}+++// ================== Normal method: "arctanh" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::arctanh"+// cWrapperName: "CasADi__MX__arctanh"+// protoArgs: "(CasADi::MX* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass MX))+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__MX__arctanh(CasADi::MX* obj)"+// call: "obj->arctanh()"+extern "C"+ CasADi::MX* CasADi__MX__arctanh(CasADi::MX* obj);+CasADi::MX* CasADi__MX__arctanh(CasADi::MX* obj){++ return new CasADi::MX( obj->arctanh() );+}+++// ================== Normal method: "logic_not" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::logic_not"+// cWrapperName: "CasADi__MX__logic_not"+// protoArgs: "(CasADi::MX* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass MX))+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__MX__logic_not(CasADi::MX* obj)"+// call: "obj->logic_not()"+extern "C"+ CasADi::MX* CasADi__MX__logic_not(CasADi::MX* obj);+CasADi::MX* CasADi__MX__logic_not(CasADi::MX* obj){++ return new CasADi::MX( obj->logic_not() );+}+++// ================== Normal method: "attachAssert" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::attachAssert"+// cWrapperName: "CasADi__MX__attachAssert"+// protoArgs: "(CasADi::MX* obj, CasADi::MX* x0, std::string* x1)"+// args: "(x0_, x1_)"+// rettype: Val (NonVec (CasadiClass MX))+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__MX__attachAssert(CasADi::MX* obj, CasADi::MX* x0, std::string* x1)"+// call: "obj->attachAssert(x0_, x1_)"+extern "C"+ CasADi::MX* CasADi__MX__attachAssert(CasADi::MX* obj, CasADi::MX* x0, std::string* x1);+CasADi::MX* CasADi__MX__attachAssert(CasADi::MX* obj, CasADi::MX* x0, std::string* x1){+ CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);+ std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);++ return new CasADi::MX( obj->attachAssert(x0_, x1_) );+}+++// ================== Normal method: "attachAssert'" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::attachAssert'"+// cWrapperName: "CasADi__MX__attachAssert_TIC"+// protoArgs: "(CasADi::MX* obj, CasADi::MX* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass MX))+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__MX__attachAssert_TIC(CasADi::MX* obj, CasADi::MX* x0)"+// call: "obj->attachAssert(x0_)"+extern "C"+ CasADi::MX* CasADi__MX__attachAssert_TIC(CasADi::MX* obj, CasADi::MX* x0);+CasADi::MX* CasADi__MX__attachAssert_TIC(CasADi::MX* obj, CasADi::MX* x0){+ CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);++ return new CasADi::MX( obj->attachAssert(x0_) );+}+++// ================== Normal method: "setSparse" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::setSparse"+// cWrapperName: "CasADi__MX__setSparse"+// protoArgs: "(CasADi::MX* obj, CasADi::CRSSparsity* x0, bool* x1)"+// args: "(x0_, x1_)"+// rettype: Val (NonVec (CasadiClass MX))+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__MX__setSparse(CasADi::MX* obj, CasADi::CRSSparsity* x0, bool* x1)"+// call: "obj->setSparse(x0_, x1_)"+extern "C"+ CasADi::MX* CasADi__MX__setSparse(CasADi::MX* obj, CasADi::CRSSparsity* x0, bool* x1);+CasADi::MX* CasADi__MX__setSparse(CasADi::MX* obj, CasADi::CRSSparsity* x0, bool* x1){+ CasADi::CRSSparsity x0_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x0);+ bool x1_ = Marshaling<bool,bool*>::marshal(x1);++ return new CasADi::MX( obj->setSparse(x0_, x1_) );+}+++// ================== Normal method: "setSparse'" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::setSparse'"+// cWrapperName: "CasADi__MX__setSparse_TIC"+// protoArgs: "(CasADi::MX* obj, CasADi::CRSSparsity* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass MX))+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__MX__setSparse_TIC(CasADi::MX* obj, CasADi::CRSSparsity* x0)"+// call: "obj->setSparse(x0_)"+extern "C"+ CasADi::MX* CasADi__MX__setSparse_TIC(CasADi::MX* obj, CasADi::CRSSparsity* x0);+CasADi::MX* CasADi__MX__setSparse_TIC(CasADi::MX* obj, CasADi::CRSSparsity* x0){+ CasADi::CRSSparsity x0_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x0);++ return new CasADi::MX( obj->setSparse(x0_) );+}+++// ================== Normal method: "makeDense" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::makeDense"+// cWrapperName: "CasADi__MX__makeDense"+// protoArgs: "(CasADi::MX* obj, CasADi::MX* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass MX))+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__MX__makeDense(CasADi::MX* obj, CasADi::MX* x0)"+// call: "obj->makeDense(x0_)"+extern "C"+ CasADi::MX* CasADi__MX__makeDense(CasADi::MX* obj, CasADi::MX* x0);+CasADi::MX* CasADi__MX__makeDense(CasADi::MX* obj, CasADi::MX* x0){+ CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);++ return new CasADi::MX( obj->makeDense(x0_) );+}+++// ================== Normal method: "makeDense'" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::makeDense'"+// cWrapperName: "CasADi__MX__makeDense_TIC"+// protoArgs: "(CasADi::MX* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass MX))+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__MX__makeDense_TIC(CasADi::MX* obj)"+// call: "obj->makeDense()"+extern "C"+ CasADi::MX* CasADi__MX__makeDense_TIC(CasADi::MX* obj);+CasADi::MX* CasADi__MX__makeDense_TIC(CasADi::MX* obj){++ return new CasADi::MX( obj->makeDense() );+}+++// ================== Normal method: "lift" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::lift"+// cWrapperName: "CasADi__MX__lift"+// protoArgs: "(CasADi::MX* obj, CasADi::MX* x0)"+// args: "(x0_)"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__MX__lift(CasADi::MX* obj, CasADi::MX* x0)"+// call: "obj->lift(x0_)"+extern "C"+ void CasADi__MX__lift(CasADi::MX* obj, CasADi::MX* x0);+void CasADi__MX__lift(CasADi::MX* obj, CasADi::MX* x0){+ CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);++ return obj->lift(x0_);+}+++// ================== Static method: "setMaxNumCallsInPrint" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::setMaxNumCallsInPrint"+// cWrapperName: "CasADi__MX__setMaxNumCallsInPrint"+// protoArgs: "(long x0)"+// args: "(x0_)"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__MX__setMaxNumCallsInPrint(long x0)"+// call: "CasADi::MX::setMaxNumCallsInPrint(x0_)"+extern "C"+ void CasADi__MX__setMaxNumCallsInPrint(long x0);+void CasADi__MX__setMaxNumCallsInPrint(long x0){+ long x0_ = Marshaling<long,long>::marshal(x0);++ return CasADi::MX::setMaxNumCallsInPrint(x0_);+}+++// ================== Static method: "setMaxNumCallsInPrint'" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::setMaxNumCallsInPrint'"+// cWrapperName: "CasADi__MX__setMaxNumCallsInPrint_TIC"+// protoArgs: "()"+// args: "()"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__MX__setMaxNumCallsInPrint_TIC()"+// call: "CasADi::MX::setMaxNumCallsInPrint()"+extern "C"+ void CasADi__MX__setMaxNumCallsInPrint_TIC();+void CasADi__MX__setMaxNumCallsInPrint_TIC(){++ return CasADi::MX::setMaxNumCallsInPrint();+}+++// ================== Static method: "getMaxNumCallsInPrint" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::getMaxNumCallsInPrint"+// cWrapperName: "CasADi__MX__getMaxNumCallsInPrint"+// protoArgs: "()"+// args: "()"+// rettype: Val (NonVec CLong)+// cWrapperRetType: "long"+// proto: "long CasADi__MX__getMaxNumCallsInPrint()"+// call: "CasADi::MX::getMaxNumCallsInPrint()"+extern "C"+ long CasADi__MX__getMaxNumCallsInPrint();+long CasADi__MX__getMaxNumCallsInPrint(){++ return CasADi::MX::getMaxNumCallsInPrint();+}+++// ================== Static method: "setEqualityCheckingDepth" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::setEqualityCheckingDepth"+// cWrapperName: "CasADi__MX__setEqualityCheckingDepth"+// protoArgs: "(int x0)"+// args: "(x0_)"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__MX__setEqualityCheckingDepth(int x0)"+// call: "CasADi::MX::setEqualityCheckingDepth(x0_)"+extern "C"+ void CasADi__MX__setEqualityCheckingDepth(int x0);+void CasADi__MX__setEqualityCheckingDepth(int x0){+ int x0_ = Marshaling<int,int>::marshal(x0);++ return CasADi::MX::setEqualityCheckingDepth(x0_);+}+++// ================== Static method: "setEqualityCheckingDepth'" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::setEqualityCheckingDepth'"+// cWrapperName: "CasADi__MX__setEqualityCheckingDepth_TIC"+// protoArgs: "()"+// args: "()"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__MX__setEqualityCheckingDepth_TIC()"+// call: "CasADi::MX::setEqualityCheckingDepth()"+extern "C"+ void CasADi__MX__setEqualityCheckingDepth_TIC();+void CasADi__MX__setEqualityCheckingDepth_TIC(){++ return CasADi::MX::setEqualityCheckingDepth();+}+++// ================== Static method: "getEqualityCheckingDepth" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX::getEqualityCheckingDepth"+// cWrapperName: "CasADi__MX__getEqualityCheckingDepth"+// protoArgs: "()"+// args: "()"+// rettype: Val (NonVec CInt)+// cWrapperRetType: "int"+// proto: "int CasADi__MX__getEqualityCheckingDepth()"+// call: "CasADi::MX::getEqualityCheckingDepth()"+extern "C"+ int CasADi__MX__getEqualityCheckingDepth();+int CasADi__MX__getEqualityCheckingDepth(){++ return CasADi::MX::getEqualityCheckingDepth();+}+++// ================== Constructor method: "MX" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX"+// cWrapperName: "CasADi__MX__MX"+// protoArgs: "()"+// args: "()"+// rettype: Val (NonVec (CasadiClass MX))+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__MX__MX()"+// call: "CasADi::MX()"+extern "C"+ CasADi::MX* CasADi__MX__MX();+CasADi::MX* CasADi__MX__MX(){++ return new CasADi::MX( CasADi::MX() );+}+++// ================== Constructor method: "MX'" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX"+// cWrapperName: "CasADi__MX__MX_TIC"+// protoArgs: "(std::string* x0, int x1, int x2)"+// args: "(x0_, x1_, x2_)"+// rettype: Val (NonVec (CasadiClass MX))+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__MX__MX_TIC(std::string* x0, int x1, int x2)"+// call: "CasADi::MX(x0_, x1_, x2_)"+extern "C"+ CasADi::MX* CasADi__MX__MX_TIC(std::string* x0, int x1, int x2);+CasADi::MX* CasADi__MX__MX_TIC(std::string* x0, int x1, int x2){+ std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);+ int x2_ = Marshaling<int,int>::marshal(x2);++ return new CasADi::MX( CasADi::MX(x0_, x1_, x2_) );+}+++// ================== Constructor method: "MX''" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX"+// cWrapperName: "CasADi__MX__MX_TIC_TIC"+// protoArgs: "(std::string* x0, int x1)"+// args: "(x0_, x1_)"+// rettype: Val (NonVec (CasadiClass MX))+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__MX__MX_TIC_TIC(std::string* x0, int x1)"+// call: "CasADi::MX(x0_, x1_)"+extern "C"+ CasADi::MX* CasADi__MX__MX_TIC_TIC(std::string* x0, int x1);+CasADi::MX* CasADi__MX__MX_TIC_TIC(std::string* x0, int x1){+ std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);++ return new CasADi::MX( CasADi::MX(x0_, x1_) );+}+++// ================== Constructor method: "MX'''" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX"+// cWrapperName: "CasADi__MX__MX_TIC_TIC_TIC"+// protoArgs: "(std::string* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass MX))+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__MX__MX_TIC_TIC_TIC(std::string* x0)"+// call: "CasADi::MX(x0_)"+extern "C"+ CasADi::MX* CasADi__MX__MX_TIC_TIC_TIC(std::string* x0);+CasADi::MX* CasADi__MX__MX_TIC_TIC_TIC(std::string* x0){+ std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);++ return new CasADi::MX( CasADi::MX(x0_) );+}+++// ================== Constructor method: "MX''''" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX"+// cWrapperName: "CasADi__MX__MX_TIC_TIC_TIC_TIC"+// protoArgs: "(std::string* x0, CasADi::CRSSparsity* x1)"+// args: "(x0_, x1_)"+// rettype: Val (NonVec (CasadiClass MX))+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__MX__MX_TIC_TIC_TIC_TIC(std::string* x0, CasADi::CRSSparsity* x1)"+// call: "CasADi::MX(x0_, x1_)"+extern "C"+ CasADi::MX* CasADi__MX__MX_TIC_TIC_TIC_TIC(std::string* x0, CasADi::CRSSparsity* x1);+CasADi::MX* CasADi__MX__MX_TIC_TIC_TIC_TIC(std::string* x0, CasADi::CRSSparsity* x1){+ std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);+ CasADi::CRSSparsity x1_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x1);++ return new CasADi::MX( CasADi::MX(x0_, x1_) );+}+++// ================== Constructor method: "MX'''''" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX"+// cWrapperName: "CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC"+// protoArgs: "(CasADi::CRSSparsity* x0, CasADi::MX* x1)"+// args: "(x0_, x1_)"+// rettype: Val (NonVec (CasadiClass MX))+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC(CasADi::CRSSparsity* x0, CasADi::MX* x1)"+// call: "CasADi::MX(x0_, x1_)"+extern "C"+ CasADi::MX* CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC(CasADi::CRSSparsity* x0, CasADi::MX* x1);+CasADi::MX* CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC(CasADi::CRSSparsity* x0, CasADi::MX* x1){+ CasADi::CRSSparsity x0_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x0);+ CasADi::MX x1_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x1);++ return new CasADi::MX( CasADi::MX(x0_, x1_) );+}+++// ================== Constructor method: "MX''''''" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX"+// cWrapperName: "CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC_TIC"+// protoArgs: "(CasADi::CRSSparsity* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass MX))+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::CRSSparsity* x0)"+// call: "CasADi::MX(x0_)"+extern "C"+ CasADi::MX* CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::CRSSparsity* x0);+CasADi::MX* CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::CRSSparsity* x0){+ CasADi::CRSSparsity x0_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x0);++ return new CasADi::MX( CasADi::MX(x0_) );+}+++// ================== Constructor method: "MX'''''''" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX"+// cWrapperName: "CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC_TIC_TIC"+// protoArgs: "(double x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass MX))+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC_TIC_TIC(double x0)"+// call: "CasADi::MX(x0_)"+extern "C"+ CasADi::MX* CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC_TIC_TIC(double x0);+CasADi::MX* CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC_TIC_TIC(double x0){+ double x0_ = Marshaling<double,double>::marshal(x0);++ return new CasADi::MX( CasADi::MX(x0_) );+}+++// ================== Constructor method: "MX''''''''" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX"+// cWrapperName: "CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"+// protoArgs: "(CasADi::MX* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass MX))+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0)"+// call: "CasADi::MX(x0_)"+extern "C"+ CasADi::MX* CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0);+CasADi::MX* CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0){+ CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);++ return new CasADi::MX( CasADi::MX(x0_) );+}+++// ================== Constructor method: "MX'''''''''" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX"+// cWrapperName: "CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"+// protoArgs: "(std::vector<double > * x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass MX))+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector<double > * x0)"+// call: "CasADi::MX(x0_)"+extern "C"+ CasADi::MX* CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector<double > * x0);+CasADi::MX* CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector<double > * x0){+ std::vector<double > x0_ = Marshaling<std::vector<double >,std::vector<double > *>::marshal(x0);++ return new CasADi::MX( CasADi::MX(x0_) );+}+++// ================== Constructor method: "MX''''''''''" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX"+// cWrapperName: "CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"+// protoArgs: "(CasADi::Matrix< double >* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass MX))+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* x0)"+// call: "CasADi::MX(x0_)"+extern "C"+ CasADi::MX* CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* x0);+CasADi::MX* CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* x0){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);++ return new CasADi::MX( CasADi::MX(x0_) );+}+++// ================== Constructor method: "MX'''''''''''" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX"+// cWrapperName: "CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"+// protoArgs: "(int x0, int x1)"+// args: "(x0_, x1_)"+// rettype: Val (NonVec (CasadiClass MX))+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(int x0, int x1)"+// call: "CasADi::MX(x0_, x1_)"+extern "C"+ CasADi::MX* CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(int x0, int x1);+CasADi::MX* CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(int x0, int x1){+ int x0_ = Marshaling<int,int>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);++ return new CasADi::MX( CasADi::MX(x0_, x1_) );+}+++// ================== Constructor method: "MX''''''''''''" ===============+// class: "CasADi::MX"+// cppName: "CasADi::MX"+// cWrapperName: "CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"+// protoArgs: "(int x0, int x1, CasADi::MX* x2)"+// args: "(x0_, x1_, x2_)"+// rettype: Val (NonVec (CasadiClass MX))+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(int x0, int x1, CasADi::MX* x2)"+// call: "CasADi::MX(x0_, x1_, x2_)"+extern "C"+ CasADi::MX* CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(int x0, int x1, CasADi::MX* x2);+CasADi::MX* CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(int x0, int x1, CasADi::MX* x2){+ int x0_ = Marshaling<int,int>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);+ CasADi::MX x2_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x2);++ return new CasADi::MX( CasADi::MX(x0_, x1_, x2_) );+}+++// ================== delete CasadiClass CasadiOptions===============+// classType: CasadiClass CasadiOptions+extern "C"+ void delete_CasADi__CasadiOptions(CasADi::CasadiOptions* obj);+void delete_CasADi__CasadiOptions(CasADi::CasadiOptions* obj){+ delete obj;+}+extern "C"+ void delete_std__vector_CasADi__CasadiOptions_(std::vector<CasADi::CasadiOptions* >* obj);+void delete_std__vector_CasADi__CasadiOptions_(std::vector<CasADi::CasadiOptions* >* obj){+ delete obj;+}+extern "C"+ void delete_std__vector_std__vector_CasADi__CasadiOptions__(std::vector<std::vector<CasADi::CasadiOptions* > >* obj);+void delete_std__vector_std__vector_CasADi__CasadiOptions__(std::vector<std::vector<CasADi::CasadiOptions* > >* obj){+ delete obj;+}+extern "C"+ void delete_std__vector_std__vector_std__vector_CasADi__CasadiOptions___(std::vector<std::vector<std::vector<CasADi::CasadiOptions* > > >* obj);+void delete_std__vector_std__vector_std__vector_CasADi__CasadiOptions___(std::vector<std::vector<std::vector<CasADi::CasadiOptions* > > >* obj){+ delete obj;+}++// ================== Static method: "setCatchErrorsPython" ===============+// class: "CasADi::CasadiOptions"+// cppName: "CasADi::CasadiOptions::setCatchErrorsPython"+// cWrapperName: "CasADi__CasadiOptions__setCatchErrorsPython"+// protoArgs: "(bool* x0)"+// args: "(x0_)"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__CasadiOptions__setCatchErrorsPython(bool* x0)"+// call: "CasADi::CasadiOptions::setCatchErrorsPython(x0_)"+extern "C"+ void CasADi__CasadiOptions__setCatchErrorsPython(bool* x0);+void CasADi__CasadiOptions__setCatchErrorsPython(bool* x0){+ bool x0_ = Marshaling<bool,bool*>::marshal(x0);++ return CasADi::CasadiOptions::setCatchErrorsPython(x0_);+}+++// ================== Static method: "getCatchErrorsPython" ===============+// class: "CasADi::CasadiOptions"+// cppName: "CasADi::CasadiOptions::getCatchErrorsPython"+// cWrapperName: "CasADi__CasadiOptions__getCatchErrorsPython"+// protoArgs: "()"+// args: "()"+// rettype: Val (NonVec CBool)+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__CasadiOptions__getCatchErrorsPython()"+// call: "CasADi::CasadiOptions::getCatchErrorsPython()"+extern "C"+ bool* CasADi__CasadiOptions__getCatchErrorsPython();+bool* CasADi__CasadiOptions__getCatchErrorsPython(){++ return new bool( CasADi::CasadiOptions::getCatchErrorsPython() );+}+++// ================== Static method: "setSimplificationOnTheFly" ===============+// class: "CasADi::CasadiOptions"+// cppName: "CasADi::CasadiOptions::setSimplificationOnTheFly"+// cWrapperName: "CasADi__CasadiOptions__setSimplificationOnTheFly"+// protoArgs: "(bool* x0)"+// args: "(x0_)"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__CasadiOptions__setSimplificationOnTheFly(bool* x0)"+// call: "CasADi::CasadiOptions::setSimplificationOnTheFly(x0_)"+extern "C"+ void CasADi__CasadiOptions__setSimplificationOnTheFly(bool* x0);+void CasADi__CasadiOptions__setSimplificationOnTheFly(bool* x0){+ bool x0_ = Marshaling<bool,bool*>::marshal(x0);++ return CasADi::CasadiOptions::setSimplificationOnTheFly(x0_);+}+++// ================== Static method: "getSimplificationOnTheFly" ===============+// class: "CasADi::CasadiOptions"+// cppName: "CasADi::CasadiOptions::getSimplificationOnTheFly"+// cWrapperName: "CasADi__CasadiOptions__getSimplificationOnTheFly"+// protoArgs: "()"+// args: "()"+// rettype: Val (NonVec CBool)+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__CasadiOptions__getSimplificationOnTheFly()"+// call: "CasADi::CasadiOptions::getSimplificationOnTheFly()"+extern "C"+ bool* CasADi__CasadiOptions__getSimplificationOnTheFly();+bool* CasADi__CasadiOptions__getSimplificationOnTheFly(){++ return new bool( CasADi::CasadiOptions::getSimplificationOnTheFly() );+}+++// ================== Static method: "startProfiling" ===============+// class: "CasADi::CasadiOptions"+// cppName: "CasADi::CasadiOptions::startProfiling"+// cWrapperName: "CasADi__CasadiOptions__startProfiling"+// protoArgs: "(std::string* x0)"+// args: "(x0_)"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__CasadiOptions__startProfiling(std::string* x0)"+// call: "CasADi::CasadiOptions::startProfiling(x0_)"+extern "C"+ void CasADi__CasadiOptions__startProfiling(std::string* x0);+void CasADi__CasadiOptions__startProfiling(std::string* x0){+ std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);++ return CasADi::CasadiOptions::startProfiling(x0_);+}+++// ================== Static method: "stopProfiling" ===============+// class: "CasADi::CasadiOptions"+// cppName: "CasADi::CasadiOptions::stopProfiling"+// cWrapperName: "CasADi__CasadiOptions__stopProfiling"+// protoArgs: "()"+// args: "()"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__CasadiOptions__stopProfiling()"+// call: "CasADi::CasadiOptions::stopProfiling()"+extern "C"+ void CasADi__CasadiOptions__stopProfiling();+void CasADi__CasadiOptions__stopProfiling(){++ return CasADi::CasadiOptions::stopProfiling();+}+++// ================== delete CasadiClass Callback===============+// classType: CasadiClass Callback+extern "C"+ void delete_CasADi__Callback(CasADi::Callback* obj);+void delete_CasADi__Callback(CasADi::Callback* obj){+ delete obj;+}+extern "C"+ void delete_std__vector_CasADi__Callback_(std::vector<CasADi::Callback* >* obj);+void delete_std__vector_CasADi__Callback_(std::vector<CasADi::Callback* >* obj){+ delete obj;+}+extern "C"+ void delete_std__vector_std__vector_CasADi__Callback__(std::vector<std::vector<CasADi::Callback* > >* obj);+void delete_std__vector_std__vector_CasADi__Callback__(std::vector<std::vector<CasADi::Callback* > >* obj){+ delete obj;+}+extern "C"+ void delete_std__vector_std__vector_std__vector_CasADi__Callback___(std::vector<std::vector<std::vector<CasADi::Callback* > > >* obj);+void delete_std__vector_std__vector_std__vector_CasADi__Callback___(std::vector<std::vector<std::vector<CasADi::Callback* > > >* obj){+ delete obj;+}++// ================== Constructor method: "Callback" ===============+// class: "CasADi::Callback"+// cppName: "CasADi::Callback"+// cWrapperName: "CasADi__Callback__Callback"+// protoArgs: "()"+// args: "()"+// rettype: Val (NonVec (CasadiClass Callback))+// cWrapperRetType: "CasADi::Callback*"+// proto: "CasADi::Callback* CasADi__Callback__Callback()"+// call: "CasADi::Callback()"+extern "C"+ CasADi::Callback* CasADi__Callback__Callback();+CasADi::Callback* CasADi__Callback__Callback(){++ return new CasADi::Callback( CasADi::Callback() );+}+++// ================== delete CasadiClass CustomEvaluate===============+// classType: CasadiClass CustomEvaluate+extern "C"+ void delete_CasADi__CustomEvaluate(CasADi::CustomEvaluate* obj);+void delete_CasADi__CustomEvaluate(CasADi::CustomEvaluate* obj){+ delete obj;+}+extern "C"+ void delete_std__vector_CasADi__CustomEvaluate_(std::vector<CasADi::CustomEvaluate* >* obj);+void delete_std__vector_CasADi__CustomEvaluate_(std::vector<CasADi::CustomEvaluate* >* obj){+ delete obj;+}+extern "C"+ void delete_std__vector_std__vector_CasADi__CustomEvaluate__(std::vector<std::vector<CasADi::CustomEvaluate* > >* obj);+void delete_std__vector_std__vector_CasADi__CustomEvaluate__(std::vector<std::vector<CasADi::CustomEvaluate* > >* obj){+ delete obj;+}+extern "C"+ void delete_std__vector_std__vector_std__vector_CasADi__CustomEvaluate___(std::vector<std::vector<std::vector<CasADi::CustomEvaluate* > > >* obj);+void delete_std__vector_std__vector_std__vector_CasADi__CustomEvaluate___(std::vector<std::vector<std::vector<CasADi::CustomEvaluate* > > >* obj){+ delete obj;+}++// ================== Constructor method: "CustomEvaluate" ===============+// class: "CasADi::CustomEvaluate"+// cppName: "CasADi::CustomEvaluate"+// cWrapperName: "CasADi__CustomEvaluate__CustomEvaluate"+// protoArgs: "()"+// args: "()"+// rettype: Val (NonVec (CasadiClass CustomEvaluate))+// cWrapperRetType: "CasADi::CustomEvaluate*"+// proto: "CasADi::CustomEvaluate* CasADi__CustomEvaluate__CustomEvaluate()"+// call: "CasADi::CustomEvaluate()"+extern "C"+ CasADi::CustomEvaluate* CasADi__CustomEvaluate__CustomEvaluate();+CasADi::CustomEvaluate* CasADi__CustomEvaluate__CustomEvaluate(){++ return new CasADi::CustomEvaluate( CasADi::CustomEvaluate() );+}+++// ================== delete CasadiClass ExternalFunction===============+// classType: CasadiClass ExternalFunction+extern "C"+ void delete_CasADi__ExternalFunction(CasADi::ExternalFunction* obj);+void delete_CasADi__ExternalFunction(CasADi::ExternalFunction* obj){+ delete obj;+}+extern "C"+ void delete_std__vector_CasADi__ExternalFunction_(std::vector<CasADi::ExternalFunction* >* obj);+void delete_std__vector_CasADi__ExternalFunction_(std::vector<CasADi::ExternalFunction* >* obj){+ delete obj;+}+extern "C"+ void delete_std__vector_std__vector_CasADi__ExternalFunction__(std::vector<std::vector<CasADi::ExternalFunction* > >* obj);+void delete_std__vector_std__vector_CasADi__ExternalFunction__(std::vector<std::vector<CasADi::ExternalFunction* > >* obj){+ delete obj;+}+extern "C"+ void delete_std__vector_std__vector_std__vector_CasADi__ExternalFunction___(std::vector<std::vector<std::vector<CasADi::ExternalFunction* > > >* obj);+void delete_std__vector_std__vector_std__vector_CasADi__ExternalFunction___(std::vector<std::vector<std::vector<CasADi::ExternalFunction* > > >* obj){+ delete obj;+}++// ================== Normal method: "checkNode" ===============+// class: "CasADi::ExternalFunction"+// cppName: "CasADi::ExternalFunction::checkNode"+// cWrapperName: "CasADi__ExternalFunction__checkNode"+// protoArgs: "(CasADi::ExternalFunction* obj)"+// args: "()"+// rettype: Val (NonVec CBool)+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__ExternalFunction__checkNode(CasADi::ExternalFunction* obj)"+// call: "obj->checkNode()"+extern "C"+ bool* CasADi__ExternalFunction__checkNode(CasADi::ExternalFunction* obj);+bool* CasADi__ExternalFunction__checkNode(CasADi::ExternalFunction* obj){++ return new bool( obj->checkNode() );+}+++// ================== Constructor method: "ExternalFunction" ===============+// class: "CasADi::ExternalFunction"+// cppName: "CasADi::ExternalFunction"+// cWrapperName: "CasADi__ExternalFunction__ExternalFunction"+// protoArgs: "()"+// args: "()"+// rettype: Val (NonVec (CasadiClass ExternalFunction))+// cWrapperRetType: "CasADi::ExternalFunction*"+// proto: "CasADi::ExternalFunction* CasADi__ExternalFunction__ExternalFunction()"+// call: "CasADi::ExternalFunction()"+extern "C"+ CasADi::ExternalFunction* CasADi__ExternalFunction__ExternalFunction();+CasADi::ExternalFunction* CasADi__ExternalFunction__ExternalFunction(){++ return new CasADi::ExternalFunction( CasADi::ExternalFunction() );+}+++// ================== Constructor method: "ExternalFunction'" ===============+// class: "CasADi::ExternalFunction"+// cppName: "CasADi::ExternalFunction"+// cWrapperName: "CasADi__ExternalFunction__ExternalFunction_TIC"+// protoArgs: "(std::string* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass ExternalFunction))+// cWrapperRetType: "CasADi::ExternalFunction*"+// proto: "CasADi::ExternalFunction* CasADi__ExternalFunction__ExternalFunction_TIC(std::string* x0)"+// call: "CasADi::ExternalFunction(x0_)"+extern "C"+ CasADi::ExternalFunction* CasADi__ExternalFunction__ExternalFunction_TIC(std::string* x0);+CasADi::ExternalFunction* CasADi__ExternalFunction__ExternalFunction_TIC(std::string* x0){+ std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);++ return new CasADi::ExternalFunction( CasADi::ExternalFunction(x0_) );+}+++// ================== delete CasadiClass CSparse===============+// classType: CasadiClass CSparse+extern "C"+ void delete_CasADi__CSparse(CasADi::CSparse* obj);+void delete_CasADi__CSparse(CasADi::CSparse* obj){+ delete obj;+}+extern "C"+ void delete_std__vector_CasADi__CSparse_(std::vector<CasADi::CSparse* >* obj);+void delete_std__vector_CasADi__CSparse_(std::vector<CasADi::CSparse* >* obj){+ delete obj;+}+extern "C"+ void delete_std__vector_std__vector_CasADi__CSparse__(std::vector<std::vector<CasADi::CSparse* > >* obj);+void delete_std__vector_std__vector_CasADi__CSparse__(std::vector<std::vector<CasADi::CSparse* > >* obj){+ delete obj;+}+extern "C"+ void delete_std__vector_std__vector_std__vector_CasADi__CSparse___(std::vector<std::vector<std::vector<CasADi::CSparse* > > >* obj);+void delete_std__vector_std__vector_std__vector_CasADi__CSparse___(std::vector<std::vector<std::vector<CasADi::CSparse* > > >* obj){+ delete obj;+}++// ================== Normal method: "checkNode" ===============+// class: "CasADi::CSparse"+// cppName: "CasADi::CSparse::checkNode"+// cWrapperName: "CasADi__CSparse__checkNode"+// protoArgs: "(CasADi::CSparse* obj)"+// args: "()"+// rettype: Val (NonVec CBool)+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__CSparse__checkNode(CasADi::CSparse* obj)"+// call: "obj->checkNode()"+extern "C"+ bool* CasADi__CSparse__checkNode(CasADi::CSparse* obj);+bool* CasADi__CSparse__checkNode(CasADi::CSparse* obj){++ return new bool( obj->checkNode() );+}+++// ================== Constructor method: "CSparse" ===============+// class: "CasADi::CSparse"+// cppName: "CasADi::CSparse"+// cWrapperName: "CasADi__CSparse__CSparse"+// protoArgs: "()"+// args: "()"+// rettype: Val (NonVec (CasadiClass CSparse))+// cWrapperRetType: "CasADi::CSparse*"+// proto: "CasADi::CSparse* CasADi__CSparse__CSparse()"+// call: "CasADi::CSparse()"+extern "C"+ CasADi::CSparse* CasADi__CSparse__CSparse();+CasADi::CSparse* CasADi__CSparse__CSparse(){++ return new CasADi::CSparse( CasADi::CSparse() );+}+++// ================== Constructor method: "CSparse'" ===============+// class: "CasADi::CSparse"+// cppName: "CasADi::CSparse"+// cWrapperName: "CasADi__CSparse__CSparse_TIC"+// protoArgs: "(CasADi::CRSSparsity* x0, int x1)"+// args: "(x0_, x1_)"+// rettype: Val (NonVec (CasadiClass CSparse))+// cWrapperRetType: "CasADi::CSparse*"+// proto: "CasADi::CSparse* CasADi__CSparse__CSparse_TIC(CasADi::CRSSparsity* x0, int x1)"+// call: "CasADi::CSparse(x0_, x1_)"+extern "C"+ CasADi::CSparse* CasADi__CSparse__CSparse_TIC(CasADi::CRSSparsity* x0, int x1);+CasADi::CSparse* CasADi__CSparse__CSparse_TIC(CasADi::CRSSparsity* x0, int x1){+ CasADi::CRSSparsity x0_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);++ return new CasADi::CSparse( CasADi::CSparse(x0_, x1_) );+}+++// ================== Constructor method: "CSparse''" ===============+// class: "CasADi::CSparse"+// cppName: "CasADi::CSparse"+// cWrapperName: "CasADi__CSparse__CSparse_TIC_TIC"+// protoArgs: "(CasADi::CRSSparsity* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass CSparse))+// cWrapperRetType: "CasADi::CSparse*"+// proto: "CasADi::CSparse* CasADi__CSparse__CSparse_TIC_TIC(CasADi::CRSSparsity* x0)"+// call: "CasADi::CSparse(x0_)"+extern "C"+ CasADi::CSparse* CasADi__CSparse__CSparse_TIC_TIC(CasADi::CRSSparsity* x0);+CasADi::CSparse* CasADi__CSparse__CSparse_TIC_TIC(CasADi::CRSSparsity* x0){+ CasADi::CRSSparsity x0_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x0);++ return new CasADi::CSparse( CasADi::CSparse(x0_) );+}+++// ================== delete CasadiClass SX===============+// classType: CasadiClass SX+extern "C"+ void delete_CasADi__SX(CasADi::SX* obj);+void delete_CasADi__SX(CasADi::SX* obj){+ delete obj;+}+extern "C"+ void delete_std__vector_CasADi__SX_(std::vector<CasADi::SX* >* obj);+void delete_std__vector_CasADi__SX_(std::vector<CasADi::SX* >* obj){+ delete obj;+}+extern "C"+ void delete_std__vector_std__vector_CasADi__SX__(std::vector<std::vector<CasADi::SX* > >* obj);+void delete_std__vector_std__vector_CasADi__SX__(std::vector<std::vector<CasADi::SX* > >* obj){+ delete obj;+}+extern "C"+ void delete_std__vector_std__vector_std__vector_CasADi__SX___(std::vector<std::vector<std::vector<CasADi::SX* > > >* obj);+void delete_std__vector_std__vector_std__vector_CasADi__SX___(std::vector<std::vector<std::vector<CasADi::SX* > > >* obj){+ delete obj;+}++// ================== Static method: "binary" ===============+// class: "CasADi::SX"+// cppName: "CasADi::SX::binary"+// cWrapperName: "CasADi__SX__binary"+// protoArgs: "(int x0, CasADi::SX* x1, CasADi::SX* x2)"+// args: "(x0_, x1_, x2_)"+// rettype: Val (NonVec (CasadiClass SX))+// cWrapperRetType: "CasADi::SX*"+// proto: "CasADi::SX* CasADi__SX__binary(int x0, CasADi::SX* x1, CasADi::SX* x2)"+// call: "CasADi::SX::binary(x0_, x1_, x2_)"+extern "C"+ CasADi::SX* CasADi__SX__binary(int x0, CasADi::SX* x1, CasADi::SX* x2);+CasADi::SX* CasADi__SX__binary(int x0, CasADi::SX* x1, CasADi::SX* x2){+ int x0_ = Marshaling<int,int>::marshal(x0);+ CasADi::SX x1_ = Marshaling<CasADi::SX,CasADi::SX*>::marshal(x1);+ CasADi::SX x2_ = Marshaling<CasADi::SX,CasADi::SX*>::marshal(x2);++ return new CasADi::SX( CasADi::SX::binary(x0_, x1_, x2_) );+}+++// ================== Static method: "unary" ===============+// class: "CasADi::SX"+// cppName: "CasADi::SX::unary"+// cWrapperName: "CasADi__SX__unary"+// protoArgs: "(int x0, CasADi::SX* x1)"+// args: "(x0_, x1_)"+// rettype: Val (NonVec (CasadiClass SX))+// cWrapperRetType: "CasADi::SX*"+// proto: "CasADi::SX* CasADi__SX__unary(int x0, CasADi::SX* x1)"+// call: "CasADi::SX::unary(x0_, x1_)"+extern "C"+ CasADi::SX* CasADi__SX__unary(int x0, CasADi::SX* x1);+CasADi::SX* CasADi__SX__unary(int x0, CasADi::SX* x1){+ int x0_ = Marshaling<int,int>::marshal(x0);+ CasADi::SX x1_ = Marshaling<CasADi::SX,CasADi::SX*>::marshal(x1);++ return new CasADi::SX( CasADi::SX::unary(x0_, x1_) );+}+++// ================== Normal method: "__nonzero__" ===============+// class: "CasADi::SX"+// cppName: "CasADi::SX::__nonzero__"+// cWrapperName: "CasADi__SX____nonzero__"+// protoArgs: "(CasADi::SX* obj)"+// args: "()"+// rettype: Val (NonVec CBool)+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__SX____nonzero__(CasADi::SX* obj)"+// call: "obj->__nonzero__()"+extern "C"+ bool* CasADi__SX____nonzero__(CasADi::SX* obj);+bool* CasADi__SX____nonzero__(CasADi::SX* obj){++ return new bool( obj->__nonzero__() );+}+++// ================== Normal method: "isLeaf" ===============+// class: "CasADi::SX"+// cppName: "CasADi::SX::isLeaf"+// cWrapperName: "CasADi__SX__isLeaf"+// protoArgs: "(CasADi::SX* obj)"+// args: "()"+// rettype: Val (NonVec CBool)+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__SX__isLeaf(CasADi::SX* obj)"+// call: "obj->isLeaf()"+extern "C"+ bool* CasADi__SX__isLeaf(CasADi::SX* obj);+bool* CasADi__SX__isLeaf(CasADi::SX* obj){++ return new bool( obj->isLeaf() );+}+++// ================== Normal method: "isConstant" ===============+// class: "CasADi::SX"+// cppName: "CasADi::SX::isConstant"+// cWrapperName: "CasADi__SX__isConstant"+// protoArgs: "(CasADi::SX* obj)"+// args: "()"+// rettype: Val (NonVec CBool)+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__SX__isConstant(CasADi::SX* obj)"+// call: "obj->isConstant()"+extern "C"+ bool* CasADi__SX__isConstant(CasADi::SX* obj);+bool* CasADi__SX__isConstant(CasADi::SX* obj){++ return new bool( obj->isConstant() );+}+++// ================== Normal method: "isInteger" ===============+// class: "CasADi::SX"+// cppName: "CasADi::SX::isInteger"+// cWrapperName: "CasADi__SX__isInteger"+// protoArgs: "(CasADi::SX* obj)"+// args: "()"+// rettype: Val (NonVec CBool)+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__SX__isInteger(CasADi::SX* obj)"+// call: "obj->isInteger()"+extern "C"+ bool* CasADi__SX__isInteger(CasADi::SX* obj);+bool* CasADi__SX__isInteger(CasADi::SX* obj){++ return new bool( obj->isInteger() );+}+++// ================== Normal method: "isSymbolic" ===============+// class: "CasADi::SX"+// cppName: "CasADi::SX::isSymbolic"+// cWrapperName: "CasADi__SX__isSymbolic"+// protoArgs: "(CasADi::SX* obj)"+// args: "()"+// rettype: Val (NonVec CBool)+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__SX__isSymbolic(CasADi::SX* obj)"+// call: "obj->isSymbolic()"+extern "C"+ bool* CasADi__SX__isSymbolic(CasADi::SX* obj);+bool* CasADi__SX__isSymbolic(CasADi::SX* obj){++ return new bool( obj->isSymbolic() );+}+++// ================== Normal method: "hasDep" ===============+// class: "CasADi::SX"+// cppName: "CasADi::SX::hasDep"+// cWrapperName: "CasADi__SX__hasDep"+// protoArgs: "(CasADi::SX* obj)"+// args: "()"+// rettype: Val (NonVec CBool)+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__SX__hasDep(CasADi::SX* obj)"+// call: "obj->hasDep()"+extern "C"+ bool* CasADi__SX__hasDep(CasADi::SX* obj);+bool* CasADi__SX__hasDep(CasADi::SX* obj){++ return new bool( obj->hasDep() );+}+++// ================== Normal method: "isCommutative" ===============+// class: "CasADi::SX"+// cppName: "CasADi::SX::isCommutative"+// cWrapperName: "CasADi__SX__isCommutative"+// protoArgs: "(CasADi::SX* obj)"+// args: "()"+// rettype: Val (NonVec CBool)+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__SX__isCommutative(CasADi::SX* obj)"+// call: "obj->isCommutative()"+extern "C"+ bool* CasADi__SX__isCommutative(CasADi::SX* obj);+bool* CasADi__SX__isCommutative(CasADi::SX* obj){++ return new bool( obj->isCommutative() );+}+++// ================== Normal method: "isZero" ===============+// class: "CasADi::SX"+// cppName: "CasADi::SX::isZero"+// cWrapperName: "CasADi__SX__isZero"+// protoArgs: "(CasADi::SX* obj)"+// args: "()"+// rettype: Val (NonVec CBool)+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__SX__isZero(CasADi::SX* obj)"+// call: "obj->isZero()"+extern "C"+ bool* CasADi__SX__isZero(CasADi::SX* obj);+bool* CasADi__SX__isZero(CasADi::SX* obj){++ return new bool( obj->isZero() );+}+++// ================== Normal method: "isOne" ===============+// class: "CasADi::SX"+// cppName: "CasADi::SX::isOne"+// cWrapperName: "CasADi__SX__isOne"+// protoArgs: "(CasADi::SX* obj)"+// args: "()"+// rettype: Val (NonVec CBool)+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__SX__isOne(CasADi::SX* obj)"+// call: "obj->isOne()"+extern "C"+ bool* CasADi__SX__isOne(CasADi::SX* obj);+bool* CasADi__SX__isOne(CasADi::SX* obj){++ return new bool( obj->isOne() );+}+++// ================== Normal method: "isMinusOne" ===============+// class: "CasADi::SX"+// cppName: "CasADi::SX::isMinusOne"+// cWrapperName: "CasADi__SX__isMinusOne"+// protoArgs: "(CasADi::SX* obj)"+// args: "()"+// rettype: Val (NonVec CBool)+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__SX__isMinusOne(CasADi::SX* obj)"+// call: "obj->isMinusOne()"+extern "C"+ bool* CasADi__SX__isMinusOne(CasADi::SX* obj);+bool* CasADi__SX__isMinusOne(CasADi::SX* obj){++ return new bool( obj->isMinusOne() );+}+++// ================== Normal method: "isNan" ===============+// class: "CasADi::SX"+// cppName: "CasADi::SX::isNan"+// cWrapperName: "CasADi__SX__isNan"+// protoArgs: "(CasADi::SX* obj)"+// args: "()"+// rettype: Val (NonVec CBool)+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__SX__isNan(CasADi::SX* obj)"+// call: "obj->isNan()"+extern "C"+ bool* CasADi__SX__isNan(CasADi::SX* obj);+bool* CasADi__SX__isNan(CasADi::SX* obj){++ return new bool( obj->isNan() );+}+++// ================== Normal method: "isInf" ===============+// class: "CasADi::SX"+// cppName: "CasADi::SX::isInf"+// cWrapperName: "CasADi__SX__isInf"+// protoArgs: "(CasADi::SX* obj)"+// args: "()"+// rettype: Val (NonVec CBool)+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__SX__isInf(CasADi::SX* obj)"+// call: "obj->isInf()"+extern "C"+ bool* CasADi__SX__isInf(CasADi::SX* obj);+bool* CasADi__SX__isInf(CasADi::SX* obj){++ return new bool( obj->isInf() );+}+++// ================== Normal method: "isMinusInf" ===============+// class: "CasADi::SX"+// cppName: "CasADi::SX::isMinusInf"+// cWrapperName: "CasADi__SX__isMinusInf"+// protoArgs: "(CasADi::SX* obj)"+// args: "()"+// rettype: Val (NonVec CBool)+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__SX__isMinusInf(CasADi::SX* obj)"+// call: "obj->isMinusInf()"+extern "C"+ bool* CasADi__SX__isMinusInf(CasADi::SX* obj);+bool* CasADi__SX__isMinusInf(CasADi::SX* obj){++ return new bool( obj->isMinusInf() );+}+++// ================== Normal method: "getOp" ===============+// class: "CasADi::SX"+// cppName: "CasADi::SX::getOp"+// cWrapperName: "CasADi__SX__getOp"+// protoArgs: "(CasADi::SX* obj)"+// args: "()"+// rettype: Val (NonVec CInt)+// cWrapperRetType: "int"+// proto: "int CasADi__SX__getOp(CasADi::SX* obj)"+// call: "obj->getOp()"+extern "C"+ int CasADi__SX__getOp(CasADi::SX* obj);+int CasADi__SX__getOp(CasADi::SX* obj){++ return obj->getOp();+}+++// ================== Normal method: "isOp" ===============+// class: "CasADi::SX"+// cppName: "CasADi::SX::isOp"+// cWrapperName: "CasADi__SX__isOp"+// protoArgs: "(CasADi::SX* obj, int x0)"+// args: "(x0_)"+// rettype: Val (NonVec CBool)+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__SX__isOp(CasADi::SX* obj, int x0)"+// call: "obj->isOp(x0_)"+extern "C"+ bool* CasADi__SX__isOp(CasADi::SX* obj, int x0);+bool* CasADi__SX__isOp(CasADi::SX* obj, int x0){+ int x0_ = Marshaling<int,int>::marshal(x0);++ return new bool( obj->isOp(x0_) );+}+++// ================== Normal method: "isEqual" ===============+// class: "CasADi::SX"+// cppName: "CasADi::SX::isEqual"+// cWrapperName: "CasADi__SX__isEqual"+// protoArgs: "(CasADi::SX* obj, CasADi::SX* x0, int x1)"+// args: "(x0_, x1_)"+// rettype: Val (NonVec CBool)+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__SX__isEqual(CasADi::SX* obj, CasADi::SX* x0, int x1)"+// call: "obj->isEqual(x0_, x1_)"+extern "C"+ bool* CasADi__SX__isEqual(CasADi::SX* obj, CasADi::SX* x0, int x1);+bool* CasADi__SX__isEqual(CasADi::SX* obj, CasADi::SX* x0, int x1){+ CasADi::SX x0_ = Marshaling<CasADi::SX,CasADi::SX*>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);++ return new bool( obj->isEqual(x0_, x1_) );+}+++// ================== Normal method: "isEqual'" ===============+// class: "CasADi::SX"+// cppName: "CasADi::SX::isEqual'"+// cWrapperName: "CasADi__SX__isEqual_TIC"+// protoArgs: "(CasADi::SX* obj, CasADi::SX* x0)"+// args: "(x0_)"+// rettype: Val (NonVec CBool)+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__SX__isEqual_TIC(CasADi::SX* obj, CasADi::SX* x0)"+// call: "obj->isEqual(x0_)"+extern "C"+ bool* CasADi__SX__isEqual_TIC(CasADi::SX* obj, CasADi::SX* x0);+bool* CasADi__SX__isEqual_TIC(CasADi::SX* obj, CasADi::SX* x0){+ CasADi::SX x0_ = Marshaling<CasADi::SX,CasADi::SX*>::marshal(x0);++ return new bool( obj->isEqual(x0_) );+}+++// ================== Normal method: "isNonNegative" ===============+// class: "CasADi::SX"+// cppName: "CasADi::SX::isNonNegative"+// cWrapperName: "CasADi__SX__isNonNegative"+// protoArgs: "(CasADi::SX* obj)"+// args: "()"+// rettype: Val (NonVec CBool)+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__SX__isNonNegative(CasADi::SX* obj)"+// call: "obj->isNonNegative()"+extern "C"+ bool* CasADi__SX__isNonNegative(CasADi::SX* obj);+bool* CasADi__SX__isNonNegative(CasADi::SX* obj){++ return new bool( obj->isNonNegative() );+}+++// ================== Normal method: "getValue" ===============+// class: "CasADi::SX"+// cppName: "CasADi::SX::getValue"+// cWrapperName: "CasADi__SX__getValue"+// protoArgs: "(CasADi::SX* obj)"+// args: "()"+// rettype: Val (NonVec CDouble)+// cWrapperRetType: "double"+// proto: "double CasADi__SX__getValue(CasADi::SX* obj)"+// call: "obj->getValue()"+extern "C"+ double CasADi__SX__getValue(CasADi::SX* obj);+double CasADi__SX__getValue(CasADi::SX* obj){++ return obj->getValue();+}+++// ================== Normal method: "getIntValue" ===============+// class: "CasADi::SX"+// cppName: "CasADi::SX::getIntValue"+// cWrapperName: "CasADi__SX__getIntValue"+// protoArgs: "(CasADi::SX* obj)"+// args: "()"+// rettype: Val (NonVec CInt)+// cWrapperRetType: "int"+// proto: "int CasADi__SX__getIntValue(CasADi::SX* obj)"+// call: "obj->getIntValue()"+extern "C"+ int CasADi__SX__getIntValue(CasADi::SX* obj);+int CasADi__SX__getIntValue(CasADi::SX* obj){++ return obj->getIntValue();+}+++// ================== Normal method: "getDep" ===============+// class: "CasADi::SX"+// cppName: "CasADi::SX::getDep"+// cWrapperName: "CasADi__SX__getDep"+// protoArgs: "(CasADi::SX* obj, int x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass SX))+// cWrapperRetType: "CasADi::SX*"+// proto: "CasADi::SX* CasADi__SX__getDep(CasADi::SX* obj, int x0)"+// call: "obj->getDep(x0_)"+extern "C"+ CasADi::SX* CasADi__SX__getDep(CasADi::SX* obj, int x0);+CasADi::SX* CasADi__SX__getDep(CasADi::SX* obj, int x0){+ int x0_ = Marshaling<int,int>::marshal(x0);++ return new CasADi::SX( obj->getDep(x0_) );+}+++// ================== Normal method: "getDep'" ===============+// class: "CasADi::SX"+// cppName: "CasADi::SX::getDep'"+// cWrapperName: "CasADi__SX__getDep_TIC"+// protoArgs: "(CasADi::SX* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass SX))+// cWrapperRetType: "CasADi::SX*"+// proto: "CasADi::SX* CasADi__SX__getDep_TIC(CasADi::SX* obj)"+// call: "obj->getDep()"+extern "C"+ CasADi::SX* CasADi__SX__getDep_TIC(CasADi::SX* obj);+CasADi::SX* CasADi__SX__getDep_TIC(CasADi::SX* obj){++ return new CasADi::SX( obj->getDep() );+}+++// ================== Normal method: "isDoubled" ===============+// class: "CasADi::SX"+// cppName: "CasADi::SX::isDoubled"+// cWrapperName: "CasADi__SX__isDoubled"+// protoArgs: "(CasADi::SX* obj)"+// args: "()"+// rettype: Val (NonVec CBool)+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__SX__isDoubled(CasADi::SX* obj)"+// call: "obj->isDoubled()"+extern "C"+ bool* CasADi__SX__isDoubled(CasADi::SX* obj);+bool* CasADi__SX__isDoubled(CasADi::SX* obj){++ return new bool( obj->isDoubled() );+}+++// ================== Normal method: "getNdeps" ===============+// class: "CasADi::SX"+// cppName: "CasADi::SX::getNdeps"+// cWrapperName: "CasADi__SX__getNdeps"+// protoArgs: "(CasADi::SX* obj)"+// args: "()"+// rettype: Val (NonVec CInt)+// cWrapperRetType: "int"+// proto: "int CasADi__SX__getNdeps(CasADi::SX* obj)"+// call: "obj->getNdeps()"+extern "C"+ int CasADi__SX__getNdeps(CasADi::SX* obj);+int CasADi__SX__getNdeps(CasADi::SX* obj){++ return obj->getNdeps();+}+++// ================== Normal method: "__hash__" ===============+// class: "CasADi::SX"+// cppName: "CasADi::SX::__hash__"+// cWrapperName: "CasADi__SX____hash__"+// protoArgs: "(CasADi::SX* obj)"+// args: "()"+// rettype: Val (NonVec CLong)+// cWrapperRetType: "long"+// proto: "long CasADi__SX____hash__(CasADi::SX* obj)"+// call: "obj->__hash__()"+extern "C"+ long CasADi__SX____hash__(CasADi::SX* obj);+long CasADi__SX____hash__(CasADi::SX* obj){++ return obj->__hash__();+}+++// ================== Normal method: "operator -" ===============+// class: "CasADi::SX"+// cppName: "CasADi::SX::operator -"+// cWrapperName: "CasADi__SX__operator_minus"+// protoArgs: "(CasADi::SX* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass SX))+// cWrapperRetType: "CasADi::SX*"+// proto: "CasADi::SX* CasADi__SX__operator_minus(CasADi::SX* obj)"+// call: "obj->operator -()"+extern "C"+ CasADi::SX* CasADi__SX__operator_minus(CasADi::SX* obj);+CasADi::SX* CasADi__SX__operator_minus(CasADi::SX* obj){++ return new CasADi::SX( obj->operator -() );+}+++// ================== Normal method: "__add__" ===============+// class: "CasADi::SX"+// cppName: "CasADi::SX::__add__"+// cWrapperName: "CasADi__SX____add__"+// protoArgs: "(CasADi::SX* obj, CasADi::SX* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass SX))+// cWrapperRetType: "CasADi::SX*"+// proto: "CasADi::SX* CasADi__SX____add__(CasADi::SX* obj, CasADi::SX* x0)"+// call: "obj->__add__(x0_)"+extern "C"+ CasADi::SX* CasADi__SX____add__(CasADi::SX* obj, CasADi::SX* x0);+CasADi::SX* CasADi__SX____add__(CasADi::SX* obj, CasADi::SX* x0){+ CasADi::SX x0_ = Marshaling<CasADi::SX,CasADi::SX*>::marshal(x0);++ return new CasADi::SX( obj->__add__(x0_) );+}+++// ================== Normal method: "__sub__" ===============+// class: "CasADi::SX"+// cppName: "CasADi::SX::__sub__"+// cWrapperName: "CasADi__SX____sub__"+// protoArgs: "(CasADi::SX* obj, CasADi::SX* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass SX))+// cWrapperRetType: "CasADi::SX*"+// proto: "CasADi::SX* CasADi__SX____sub__(CasADi::SX* obj, CasADi::SX* x0)"+// call: "obj->__sub__(x0_)"+extern "C"+ CasADi::SX* CasADi__SX____sub__(CasADi::SX* obj, CasADi::SX* x0);+CasADi::SX* CasADi__SX____sub__(CasADi::SX* obj, CasADi::SX* x0){+ CasADi::SX x0_ = Marshaling<CasADi::SX,CasADi::SX*>::marshal(x0);++ return new CasADi::SX( obj->__sub__(x0_) );+}+++// ================== Normal method: "__mul__" ===============+// class: "CasADi::SX"+// cppName: "CasADi::SX::__mul__"+// cWrapperName: "CasADi__SX____mul__"+// protoArgs: "(CasADi::SX* obj, CasADi::SX* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass SX))+// cWrapperRetType: "CasADi::SX*"+// proto: "CasADi::SX* CasADi__SX____mul__(CasADi::SX* obj, CasADi::SX* x0)"+// call: "obj->__mul__(x0_)"+extern "C"+ CasADi::SX* CasADi__SX____mul__(CasADi::SX* obj, CasADi::SX* x0);+CasADi::SX* CasADi__SX____mul__(CasADi::SX* obj, CasADi::SX* x0){+ CasADi::SX x0_ = Marshaling<CasADi::SX,CasADi::SX*>::marshal(x0);++ return new CasADi::SX( obj->__mul__(x0_) );+}+++// ================== Normal method: "__div__" ===============+// class: "CasADi::SX"+// cppName: "CasADi::SX::__div__"+// cWrapperName: "CasADi__SX____div__"+// protoArgs: "(CasADi::SX* obj, CasADi::SX* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass SX))+// cWrapperRetType: "CasADi::SX*"+// proto: "CasADi::SX* CasADi__SX____div__(CasADi::SX* obj, CasADi::SX* x0)"+// call: "obj->__div__(x0_)"+extern "C"+ CasADi::SX* CasADi__SX____div__(CasADi::SX* obj, CasADi::SX* x0);+CasADi::SX* CasADi__SX____div__(CasADi::SX* obj, CasADi::SX* x0){+ CasADi::SX x0_ = Marshaling<CasADi::SX,CasADi::SX*>::marshal(x0);++ return new CasADi::SX( obj->__div__(x0_) );+}+++// ================== Normal method: "__lt__" ===============+// class: "CasADi::SX"+// cppName: "CasADi::SX::__lt__"+// cWrapperName: "CasADi__SX____lt__"+// protoArgs: "(CasADi::SX* obj, CasADi::SX* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass SX))+// cWrapperRetType: "CasADi::SX*"+// proto: "CasADi::SX* CasADi__SX____lt__(CasADi::SX* obj, CasADi::SX* x0)"+// call: "obj->__lt__(x0_)"+extern "C"+ CasADi::SX* CasADi__SX____lt__(CasADi::SX* obj, CasADi::SX* x0);+CasADi::SX* CasADi__SX____lt__(CasADi::SX* obj, CasADi::SX* x0){+ CasADi::SX x0_ = Marshaling<CasADi::SX,CasADi::SX*>::marshal(x0);++ return new CasADi::SX( obj->__lt__(x0_) );+}+++// ================== Normal method: "__le__" ===============+// class: "CasADi::SX"+// cppName: "CasADi::SX::__le__"+// cWrapperName: "CasADi__SX____le__"+// protoArgs: "(CasADi::SX* obj, CasADi::SX* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass SX))+// cWrapperRetType: "CasADi::SX*"+// proto: "CasADi::SX* CasADi__SX____le__(CasADi::SX* obj, CasADi::SX* x0)"+// call: "obj->__le__(x0_)"+extern "C"+ CasADi::SX* CasADi__SX____le__(CasADi::SX* obj, CasADi::SX* x0);+CasADi::SX* CasADi__SX____le__(CasADi::SX* obj, CasADi::SX* x0){+ CasADi::SX x0_ = Marshaling<CasADi::SX,CasADi::SX*>::marshal(x0);++ return new CasADi::SX( obj->__le__(x0_) );+}+++// ================== Normal method: "__eq__" ===============+// class: "CasADi::SX"+// cppName: "CasADi::SX::__eq__"+// cWrapperName: "CasADi__SX____eq__"+// protoArgs: "(CasADi::SX* obj, CasADi::SX* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass SX))+// cWrapperRetType: "CasADi::SX*"+// proto: "CasADi::SX* CasADi__SX____eq__(CasADi::SX* obj, CasADi::SX* x0)"+// call: "obj->__eq__(x0_)"+extern "C"+ CasADi::SX* CasADi__SX____eq__(CasADi::SX* obj, CasADi::SX* x0);+CasADi::SX* CasADi__SX____eq__(CasADi::SX* obj, CasADi::SX* x0){+ CasADi::SX x0_ = Marshaling<CasADi::SX,CasADi::SX*>::marshal(x0);++ return new CasADi::SX( obj->__eq__(x0_) );+}+++// ================== Normal method: "__ne__" ===============+// class: "CasADi::SX"+// cppName: "CasADi::SX::__ne__"+// cWrapperName: "CasADi__SX____ne__"+// protoArgs: "(CasADi::SX* obj, CasADi::SX* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass SX))+// cWrapperRetType: "CasADi::SX*"+// proto: "CasADi::SX* CasADi__SX____ne__(CasADi::SX* obj, CasADi::SX* x0)"+// call: "obj->__ne__(x0_)"+extern "C"+ CasADi::SX* CasADi__SX____ne__(CasADi::SX* obj, CasADi::SX* x0);+CasADi::SX* CasADi__SX____ne__(CasADi::SX* obj, CasADi::SX* x0){+ CasADi::SX x0_ = Marshaling<CasADi::SX,CasADi::SX*>::marshal(x0);++ return new CasADi::SX( obj->__ne__(x0_) );+}+++// ================== Normal method: "__truediv__" ===============+// class: "CasADi::SX"+// cppName: "CasADi::SX::__truediv__"+// cWrapperName: "CasADi__SX____truediv__"+// protoArgs: "(CasADi::SX* obj, CasADi::SX* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass SX))+// cWrapperRetType: "CasADi::SX*"+// proto: "CasADi::SX* CasADi__SX____truediv__(CasADi::SX* obj, CasADi::SX* x0)"+// call: "obj->__truediv__(x0_)"+extern "C"+ CasADi::SX* CasADi__SX____truediv__(CasADi::SX* obj, CasADi::SX* x0);+CasADi::SX* CasADi__SX____truediv__(CasADi::SX* obj, CasADi::SX* x0){+ CasADi::SX x0_ = Marshaling<CasADi::SX,CasADi::SX*>::marshal(x0);++ return new CasADi::SX( obj->__truediv__(x0_) );+}+++// ================== Normal method: "__pow__" ===============+// class: "CasADi::SX"+// cppName: "CasADi::SX::__pow__"+// cWrapperName: "CasADi__SX____pow__"+// protoArgs: "(CasADi::SX* obj, CasADi::SX* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass SX))+// cWrapperRetType: "CasADi::SX*"+// proto: "CasADi::SX* CasADi__SX____pow__(CasADi::SX* obj, CasADi::SX* x0)"+// call: "obj->__pow__(x0_)"+extern "C"+ CasADi::SX* CasADi__SX____pow__(CasADi::SX* obj, CasADi::SX* x0);+CasADi::SX* CasADi__SX____pow__(CasADi::SX* obj, CasADi::SX* x0){+ CasADi::SX x0_ = Marshaling<CasADi::SX,CasADi::SX*>::marshal(x0);++ return new CasADi::SX( obj->__pow__(x0_) );+}+++// ================== Normal method: "__constpow__" ===============+// class: "CasADi::SX"+// cppName: "CasADi::SX::__constpow__"+// cWrapperName: "CasADi__SX____constpow__"+// protoArgs: "(CasADi::SX* obj, CasADi::SX* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass SX))+// cWrapperRetType: "CasADi::SX*"+// proto: "CasADi::SX* CasADi__SX____constpow__(CasADi::SX* obj, CasADi::SX* x0)"+// call: "obj->__constpow__(x0_)"+extern "C"+ CasADi::SX* CasADi__SX____constpow__(CasADi::SX* obj, CasADi::SX* x0);+CasADi::SX* CasADi__SX____constpow__(CasADi::SX* obj, CasADi::SX* x0){+ CasADi::SX x0_ = Marshaling<CasADi::SX,CasADi::SX*>::marshal(x0);++ return new CasADi::SX( obj->__constpow__(x0_) );+}+++// ================== Normal method: "__mrdivide__" ===============+// class: "CasADi::SX"+// cppName: "CasADi::SX::__mrdivide__"+// cWrapperName: "CasADi__SX____mrdivide__"+// protoArgs: "(CasADi::SX* obj, CasADi::SX* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass SX))+// cWrapperRetType: "CasADi::SX*"+// proto: "CasADi::SX* CasADi__SX____mrdivide__(CasADi::SX* obj, CasADi::SX* x0)"+// call: "obj->__mrdivide__(x0_)"+extern "C"+ CasADi::SX* CasADi__SX____mrdivide__(CasADi::SX* obj, CasADi::SX* x0);+CasADi::SX* CasADi__SX____mrdivide__(CasADi::SX* obj, CasADi::SX* x0){+ CasADi::SX x0_ = Marshaling<CasADi::SX,CasADi::SX*>::marshal(x0);++ return new CasADi::SX( obj->__mrdivide__(x0_) );+}+++// ================== Normal method: "__mpower__" ===============+// class: "CasADi::SX"+// cppName: "CasADi::SX::__mpower__"+// cWrapperName: "CasADi__SX____mpower__"+// protoArgs: "(CasADi::SX* obj, CasADi::SX* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass SX))+// cWrapperRetType: "CasADi::SX*"+// proto: "CasADi::SX* CasADi__SX____mpower__(CasADi::SX* obj, CasADi::SX* x0)"+// call: "obj->__mpower__(x0_)"+extern "C"+ CasADi::SX* CasADi__SX____mpower__(CasADi::SX* obj, CasADi::SX* x0);+CasADi::SX* CasADi__SX____mpower__(CasADi::SX* obj, CasADi::SX* x0){+ CasADi::SX x0_ = Marshaling<CasADi::SX,CasADi::SX*>::marshal(x0);++ return new CasADi::SX( obj->__mpower__(x0_) );+}+++// ================== Normal method: "trans" ===============+// class: "CasADi::SX"+// cppName: "CasADi::SX::trans"+// cWrapperName: "CasADi__SX__trans"+// protoArgs: "(CasADi::SX* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass SX))+// cWrapperRetType: "CasADi::SX*"+// proto: "CasADi::SX* CasADi__SX__trans(CasADi::SX* obj)"+// call: "obj->trans()"+extern "C"+ CasADi::SX* CasADi__SX__trans(CasADi::SX* obj);+CasADi::SX* CasADi__SX__trans(CasADi::SX* obj){++ return new CasADi::SX( obj->trans() );+}+++// ================== Normal method: "mul" ===============+// class: "CasADi::SX"+// cppName: "CasADi::SX::mul"+// cWrapperName: "CasADi__SX__mul"+// protoArgs: "(CasADi::SX* obj, CasADi::SX* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass SX))+// cWrapperRetType: "CasADi::SX*"+// proto: "CasADi::SX* CasADi__SX__mul(CasADi::SX* obj, CasADi::SX* x0)"+// call: "obj->mul(x0_)"+extern "C"+ CasADi::SX* CasADi__SX__mul(CasADi::SX* obj, CasADi::SX* x0);+CasADi::SX* CasADi__SX__mul(CasADi::SX* obj, CasADi::SX* x0){+ CasADi::SX x0_ = Marshaling<CasADi::SX,CasADi::SX*>::marshal(x0);++ return new CasADi::SX( obj->mul(x0_) );+}+++// ================== Normal method: "exp" ===============+// class: "CasADi::SX"+// cppName: "CasADi::SX::exp"+// cWrapperName: "CasADi__SX__exp"+// protoArgs: "(CasADi::SX* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass SX))+// cWrapperRetType: "CasADi::SX*"+// proto: "CasADi::SX* CasADi__SX__exp(CasADi::SX* obj)"+// call: "obj->exp()"+extern "C"+ CasADi::SX* CasADi__SX__exp(CasADi::SX* obj);+CasADi::SX* CasADi__SX__exp(CasADi::SX* obj){++ return new CasADi::SX( obj->exp() );+}+++// ================== Normal method: "log" ===============+// class: "CasADi::SX"+// cppName: "CasADi::SX::log"+// cWrapperName: "CasADi__SX__log"+// protoArgs: "(CasADi::SX* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass SX))+// cWrapperRetType: "CasADi::SX*"+// proto: "CasADi::SX* CasADi__SX__log(CasADi::SX* obj)"+// call: "obj->log()"+extern "C"+ CasADi::SX* CasADi__SX__log(CasADi::SX* obj);+CasADi::SX* CasADi__SX__log(CasADi::SX* obj){++ return new CasADi::SX( obj->log() );+}+++// ================== Normal method: "sqrt" ===============+// class: "CasADi::SX"+// cppName: "CasADi::SX::sqrt"+// cWrapperName: "CasADi__SX__sqrt"+// protoArgs: "(CasADi::SX* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass SX))+// cWrapperRetType: "CasADi::SX*"+// proto: "CasADi::SX* CasADi__SX__sqrt(CasADi::SX* obj)"+// call: "obj->sqrt()"+extern "C"+ CasADi::SX* CasADi__SX__sqrt(CasADi::SX* obj);+CasADi::SX* CasADi__SX__sqrt(CasADi::SX* obj){++ return new CasADi::SX( obj->sqrt() );+}+++// ================== Normal method: "sq" ===============+// class: "CasADi::SX"+// cppName: "CasADi::SX::sq"+// cWrapperName: "CasADi__SX__sq"+// protoArgs: "(CasADi::SX* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass SX))+// cWrapperRetType: "CasADi::SX*"+// proto: "CasADi::SX* CasADi__SX__sq(CasADi::SX* obj)"+// call: "obj->sq()"+extern "C"+ CasADi::SX* CasADi__SX__sq(CasADi::SX* obj);+CasADi::SX* CasADi__SX__sq(CasADi::SX* obj){++ return new CasADi::SX( obj->sq() );+}+++// ================== Normal method: "sin" ===============+// class: "CasADi::SX"+// cppName: "CasADi::SX::sin"+// cWrapperName: "CasADi__SX__sin"+// protoArgs: "(CasADi::SX* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass SX))+// cWrapperRetType: "CasADi::SX*"+// proto: "CasADi::SX* CasADi__SX__sin(CasADi::SX* obj)"+// call: "obj->sin()"+extern "C"+ CasADi::SX* CasADi__SX__sin(CasADi::SX* obj);+CasADi::SX* CasADi__SX__sin(CasADi::SX* obj){++ return new CasADi::SX( obj->sin() );+}+++// ================== Normal method: "cos" ===============+// class: "CasADi::SX"+// cppName: "CasADi::SX::cos"+// cWrapperName: "CasADi__SX__cos"+// protoArgs: "(CasADi::SX* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass SX))+// cWrapperRetType: "CasADi::SX*"+// proto: "CasADi::SX* CasADi__SX__cos(CasADi::SX* obj)"+// call: "obj->cos()"+extern "C"+ CasADi::SX* CasADi__SX__cos(CasADi::SX* obj);+CasADi::SX* CasADi__SX__cos(CasADi::SX* obj){++ return new CasADi::SX( obj->cos() );+}+++// ================== Normal method: "tan" ===============+// class: "CasADi::SX"+// cppName: "CasADi::SX::tan"+// cWrapperName: "CasADi__SX__tan"+// protoArgs: "(CasADi::SX* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass SX))+// cWrapperRetType: "CasADi::SX*"+// proto: "CasADi::SX* CasADi__SX__tan(CasADi::SX* obj)"+// call: "obj->tan()"+extern "C"+ CasADi::SX* CasADi__SX__tan(CasADi::SX* obj);+CasADi::SX* CasADi__SX__tan(CasADi::SX* obj){++ return new CasADi::SX( obj->tan() );+}+++// ================== Normal method: "arcsin" ===============+// class: "CasADi::SX"+// cppName: "CasADi::SX::arcsin"+// cWrapperName: "CasADi__SX__arcsin"+// protoArgs: "(CasADi::SX* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass SX))+// cWrapperRetType: "CasADi::SX*"+// proto: "CasADi::SX* CasADi__SX__arcsin(CasADi::SX* obj)"+// call: "obj->arcsin()"+extern "C"+ CasADi::SX* CasADi__SX__arcsin(CasADi::SX* obj);+CasADi::SX* CasADi__SX__arcsin(CasADi::SX* obj){++ return new CasADi::SX( obj->arcsin() );+}+++// ================== Normal method: "arccos" ===============+// class: "CasADi::SX"+// cppName: "CasADi::SX::arccos"+// cWrapperName: "CasADi__SX__arccos"+// protoArgs: "(CasADi::SX* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass SX))+// cWrapperRetType: "CasADi::SX*"+// proto: "CasADi::SX* CasADi__SX__arccos(CasADi::SX* obj)"+// call: "obj->arccos()"+extern "C"+ CasADi::SX* CasADi__SX__arccos(CasADi::SX* obj);+CasADi::SX* CasADi__SX__arccos(CasADi::SX* obj){++ return new CasADi::SX( obj->arccos() );+}+++// ================== Normal method: "arctan" ===============+// class: "CasADi::SX"+// cppName: "CasADi::SX::arctan"+// cWrapperName: "CasADi__SX__arctan"+// protoArgs: "(CasADi::SX* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass SX))+// cWrapperRetType: "CasADi::SX*"+// proto: "CasADi::SX* CasADi__SX__arctan(CasADi::SX* obj)"+// call: "obj->arctan()"+extern "C"+ CasADi::SX* CasADi__SX__arctan(CasADi::SX* obj);+CasADi::SX* CasADi__SX__arctan(CasADi::SX* obj){++ return new CasADi::SX( obj->arctan() );+}+++// ================== Normal method: "floor" ===============+// class: "CasADi::SX"+// cppName: "CasADi::SX::floor"+// cWrapperName: "CasADi__SX__floor"+// protoArgs: "(CasADi::SX* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass SX))+// cWrapperRetType: "CasADi::SX*"+// proto: "CasADi::SX* CasADi__SX__floor(CasADi::SX* obj)"+// call: "obj->floor()"+extern "C"+ CasADi::SX* CasADi__SX__floor(CasADi::SX* obj);+CasADi::SX* CasADi__SX__floor(CasADi::SX* obj){++ return new CasADi::SX( obj->floor() );+}+++// ================== Normal method: "ceil" ===============+// class: "CasADi::SX"+// cppName: "CasADi::SX::ceil"+// cWrapperName: "CasADi__SX__ceil"+// protoArgs: "(CasADi::SX* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass SX))+// cWrapperRetType: "CasADi::SX*"+// proto: "CasADi::SX* CasADi__SX__ceil(CasADi::SX* obj)"+// call: "obj->ceil()"+extern "C"+ CasADi::SX* CasADi__SX__ceil(CasADi::SX* obj);+CasADi::SX* CasADi__SX__ceil(CasADi::SX* obj){++ return new CasADi::SX( obj->ceil() );+}+++// ================== Normal method: "erf" ===============+// class: "CasADi::SX"+// cppName: "CasADi::SX::erf"+// cWrapperName: "CasADi__SX__erf"+// protoArgs: "(CasADi::SX* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass SX))+// cWrapperRetType: "CasADi::SX*"+// proto: "CasADi::SX* CasADi__SX__erf(CasADi::SX* obj)"+// call: "obj->erf()"+extern "C"+ CasADi::SX* CasADi__SX__erf(CasADi::SX* obj);+CasADi::SX* CasADi__SX__erf(CasADi::SX* obj){++ return new CasADi::SX( obj->erf() );+}+++// ================== Normal method: "erfinv" ===============+// class: "CasADi::SX"+// cppName: "CasADi::SX::erfinv"+// cWrapperName: "CasADi__SX__erfinv"+// protoArgs: "(CasADi::SX* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass SX))+// cWrapperRetType: "CasADi::SX*"+// proto: "CasADi::SX* CasADi__SX__erfinv(CasADi::SX* obj)"+// call: "obj->erfinv()"+extern "C"+ CasADi::SX* CasADi__SX__erfinv(CasADi::SX* obj);+CasADi::SX* CasADi__SX__erfinv(CasADi::SX* obj){++ return new CasADi::SX( obj->erfinv() );+}+++// ================== Normal method: "fabs" ===============+// class: "CasADi::SX"+// cppName: "CasADi::SX::fabs"+// cWrapperName: "CasADi__SX__fabs"+// protoArgs: "(CasADi::SX* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass SX))+// cWrapperRetType: "CasADi::SX*"+// proto: "CasADi::SX* CasADi__SX__fabs(CasADi::SX* obj)"+// call: "obj->fabs()"+extern "C"+ CasADi::SX* CasADi__SX__fabs(CasADi::SX* obj);+CasADi::SX* CasADi__SX__fabs(CasADi::SX* obj){++ return new CasADi::SX( obj->fabs() );+}+++// ================== Normal method: "fmin" ===============+// class: "CasADi::SX"+// cppName: "CasADi::SX::fmin"+// cWrapperName: "CasADi__SX__fmin"+// protoArgs: "(CasADi::SX* obj, CasADi::SX* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass SX))+// cWrapperRetType: "CasADi::SX*"+// proto: "CasADi::SX* CasADi__SX__fmin(CasADi::SX* obj, CasADi::SX* x0)"+// call: "obj->fmin(x0_)"+extern "C"+ CasADi::SX* CasADi__SX__fmin(CasADi::SX* obj, CasADi::SX* x0);+CasADi::SX* CasADi__SX__fmin(CasADi::SX* obj, CasADi::SX* x0){+ CasADi::SX x0_ = Marshaling<CasADi::SX,CasADi::SX*>::marshal(x0);++ return new CasADi::SX( obj->fmin(x0_) );+}+++// ================== Normal method: "fmax" ===============+// class: "CasADi::SX"+// cppName: "CasADi::SX::fmax"+// cWrapperName: "CasADi__SX__fmax"+// protoArgs: "(CasADi::SX* obj, CasADi::SX* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass SX))+// cWrapperRetType: "CasADi::SX*"+// proto: "CasADi::SX* CasADi__SX__fmax(CasADi::SX* obj, CasADi::SX* x0)"+// call: "obj->fmax(x0_)"+extern "C"+ CasADi::SX* CasADi__SX__fmax(CasADi::SX* obj, CasADi::SX* x0);+CasADi::SX* CasADi__SX__fmax(CasADi::SX* obj, CasADi::SX* x0){+ CasADi::SX x0_ = Marshaling<CasADi::SX,CasADi::SX*>::marshal(x0);++ return new CasADi::SX( obj->fmax(x0_) );+}+++// ================== Normal method: "inv" ===============+// class: "CasADi::SX"+// cppName: "CasADi::SX::inv"+// cWrapperName: "CasADi__SX__inv"+// protoArgs: "(CasADi::SX* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass SX))+// cWrapperRetType: "CasADi::SX*"+// proto: "CasADi::SX* CasADi__SX__inv(CasADi::SX* obj)"+// call: "obj->inv()"+extern "C"+ CasADi::SX* CasADi__SX__inv(CasADi::SX* obj);+CasADi::SX* CasADi__SX__inv(CasADi::SX* obj){++ return new CasADi::SX( obj->inv() );+}+++// ================== Normal method: "sinh" ===============+// class: "CasADi::SX"+// cppName: "CasADi::SX::sinh"+// cWrapperName: "CasADi__SX__sinh"+// protoArgs: "(CasADi::SX* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass SX))+// cWrapperRetType: "CasADi::SX*"+// proto: "CasADi::SX* CasADi__SX__sinh(CasADi::SX* obj)"+// call: "obj->sinh()"+extern "C"+ CasADi::SX* CasADi__SX__sinh(CasADi::SX* obj);+CasADi::SX* CasADi__SX__sinh(CasADi::SX* obj){++ return new CasADi::SX( obj->sinh() );+}+++// ================== Normal method: "cosh" ===============+// class: "CasADi::SX"+// cppName: "CasADi::SX::cosh"+// cWrapperName: "CasADi__SX__cosh"+// protoArgs: "(CasADi::SX* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass SX))+// cWrapperRetType: "CasADi::SX*"+// proto: "CasADi::SX* CasADi__SX__cosh(CasADi::SX* obj)"+// call: "obj->cosh()"+extern "C"+ CasADi::SX* CasADi__SX__cosh(CasADi::SX* obj);+CasADi::SX* CasADi__SX__cosh(CasADi::SX* obj){++ return new CasADi::SX( obj->cosh() );+}+++// ================== Normal method: "tanh" ===============+// class: "CasADi::SX"+// cppName: "CasADi::SX::tanh"+// cWrapperName: "CasADi__SX__tanh"+// protoArgs: "(CasADi::SX* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass SX))+// cWrapperRetType: "CasADi::SX*"+// proto: "CasADi::SX* CasADi__SX__tanh(CasADi::SX* obj)"+// call: "obj->tanh()"+extern "C"+ CasADi::SX* CasADi__SX__tanh(CasADi::SX* obj);+CasADi::SX* CasADi__SX__tanh(CasADi::SX* obj){++ return new CasADi::SX( obj->tanh() );+}+++// ================== Normal method: "arcsinh" ===============+// class: "CasADi::SX"+// cppName: "CasADi::SX::arcsinh"+// cWrapperName: "CasADi__SX__arcsinh"+// protoArgs: "(CasADi::SX* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass SX))+// cWrapperRetType: "CasADi::SX*"+// proto: "CasADi::SX* CasADi__SX__arcsinh(CasADi::SX* obj)"+// call: "obj->arcsinh()"+extern "C"+ CasADi::SX* CasADi__SX__arcsinh(CasADi::SX* obj);+CasADi::SX* CasADi__SX__arcsinh(CasADi::SX* obj){++ return new CasADi::SX( obj->arcsinh() );+}+++// ================== Normal method: "arccosh" ===============+// class: "CasADi::SX"+// cppName: "CasADi::SX::arccosh"+// cWrapperName: "CasADi__SX__arccosh"+// protoArgs: "(CasADi::SX* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass SX))+// cWrapperRetType: "CasADi::SX*"+// proto: "CasADi::SX* CasADi__SX__arccosh(CasADi::SX* obj)"+// call: "obj->arccosh()"+extern "C"+ CasADi::SX* CasADi__SX__arccosh(CasADi::SX* obj);+CasADi::SX* CasADi__SX__arccosh(CasADi::SX* obj){++ return new CasADi::SX( obj->arccosh() );+}+++// ================== Normal method: "arctanh" ===============+// class: "CasADi::SX"+// cppName: "CasADi::SX::arctanh"+// cWrapperName: "CasADi__SX__arctanh"+// protoArgs: "(CasADi::SX* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass SX))+// cWrapperRetType: "CasADi::SX*"+// proto: "CasADi::SX* CasADi__SX__arctanh(CasADi::SX* obj)"+// call: "obj->arctanh()"+extern "C"+ CasADi::SX* CasADi__SX__arctanh(CasADi::SX* obj);+CasADi::SX* CasADi__SX__arctanh(CasADi::SX* obj){++ return new CasADi::SX( obj->arctanh() );+}+++// ================== Normal method: "arctan2" ===============+// class: "CasADi::SX"+// cppName: "CasADi::SX::arctan2"+// cWrapperName: "CasADi__SX__arctan2"+// protoArgs: "(CasADi::SX* obj, CasADi::SX* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass SX))+// cWrapperRetType: "CasADi::SX*"+// proto: "CasADi::SX* CasADi__SX__arctan2(CasADi::SX* obj, CasADi::SX* x0)"+// call: "obj->arctan2(x0_)"+extern "C"+ CasADi::SX* CasADi__SX__arctan2(CasADi::SX* obj, CasADi::SX* x0);+CasADi::SX* CasADi__SX__arctan2(CasADi::SX* obj, CasADi::SX* x0){+ CasADi::SX x0_ = Marshaling<CasADi::SX,CasADi::SX*>::marshal(x0);++ return new CasADi::SX( obj->arctan2(x0_) );+}+++// ================== Normal method: "log10" ===============+// class: "CasADi::SX"+// cppName: "CasADi::SX::log10"+// cWrapperName: "CasADi__SX__log10"+// protoArgs: "(CasADi::SX* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass SX))+// cWrapperRetType: "CasADi::SX*"+// proto: "CasADi::SX* CasADi__SX__log10(CasADi::SX* obj)"+// call: "obj->log10()"+extern "C"+ CasADi::SX* CasADi__SX__log10(CasADi::SX* obj);+CasADi::SX* CasADi__SX__log10(CasADi::SX* obj){++ return new CasADi::SX( obj->log10() );+}+++// ================== Normal method: "printme" ===============+// class: "CasADi::SX"+// cppName: "CasADi::SX::printme"+// cWrapperName: "CasADi__SX__printme"+// protoArgs: "(CasADi::SX* obj, CasADi::SX* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass SX))+// cWrapperRetType: "CasADi::SX*"+// proto: "CasADi::SX* CasADi__SX__printme(CasADi::SX* obj, CasADi::SX* x0)"+// call: "obj->printme(x0_)"+extern "C"+ CasADi::SX* CasADi__SX__printme(CasADi::SX* obj, CasADi::SX* x0);+CasADi::SX* CasADi__SX__printme(CasADi::SX* obj, CasADi::SX* x0){+ CasADi::SX x0_ = Marshaling<CasADi::SX,CasADi::SX*>::marshal(x0);++ return new CasADi::SX( obj->printme(x0_) );+}+++// ================== Normal method: "sign" ===============+// class: "CasADi::SX"+// cppName: "CasADi::SX::sign"+// cWrapperName: "CasADi__SX__sign"+// protoArgs: "(CasADi::SX* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass SX))+// cWrapperRetType: "CasADi::SX*"+// proto: "CasADi::SX* CasADi__SX__sign(CasADi::SX* obj)"+// call: "obj->sign()"+extern "C"+ CasADi::SX* CasADi__SX__sign(CasADi::SX* obj);+CasADi::SX* CasADi__SX__sign(CasADi::SX* obj){++ return new CasADi::SX( obj->sign() );+}+++// ================== Normal method: "constpow" ===============+// class: "CasADi::SX"+// cppName: "CasADi::SX::constpow"+// cWrapperName: "CasADi__SX__constpow"+// protoArgs: "(CasADi::SX* obj, CasADi::SX* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass SX))+// cWrapperRetType: "CasADi::SX*"+// proto: "CasADi::SX* CasADi__SX__constpow(CasADi::SX* obj, CasADi::SX* x0)"+// call: "obj->constpow(x0_)"+extern "C"+ CasADi::SX* CasADi__SX__constpow(CasADi::SX* obj, CasADi::SX* x0);+CasADi::SX* CasADi__SX__constpow(CasADi::SX* obj, CasADi::SX* x0){+ CasADi::SX x0_ = Marshaling<CasADi::SX,CasADi::SX*>::marshal(x0);++ return new CasADi::SX( obj->constpow(x0_) );+}+++// ================== Normal method: "logic_not" ===============+// class: "CasADi::SX"+// cppName: "CasADi::SX::logic_not"+// cWrapperName: "CasADi__SX__logic_not"+// protoArgs: "(CasADi::SX* obj)"+// args: "()"+// rettype: Val (NonVec (CasadiClass SX))+// cWrapperRetType: "CasADi::SX*"+// proto: "CasADi::SX* CasADi__SX__logic_not(CasADi::SX* obj)"+// call: "obj->logic_not()"+extern "C"+ CasADi::SX* CasADi__SX__logic_not(CasADi::SX* obj);+CasADi::SX* CasADi__SX__logic_not(CasADi::SX* obj){++ return new CasADi::SX( obj->logic_not() );+}+++// ================== Normal method: "logic_and" ===============+// class: "CasADi::SX"+// cppName: "CasADi::SX::logic_and"+// cWrapperName: "CasADi__SX__logic_and"+// protoArgs: "(CasADi::SX* obj, CasADi::SX* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass SX))+// cWrapperRetType: "CasADi::SX*"+// proto: "CasADi::SX* CasADi__SX__logic_and(CasADi::SX* obj, CasADi::SX* x0)"+// call: "obj->logic_and(x0_)"+extern "C"+ CasADi::SX* CasADi__SX__logic_and(CasADi::SX* obj, CasADi::SX* x0);+CasADi::SX* CasADi__SX__logic_and(CasADi::SX* obj, CasADi::SX* x0){+ CasADi::SX x0_ = Marshaling<CasADi::SX,CasADi::SX*>::marshal(x0);++ return new CasADi::SX( obj->logic_and(x0_) );+}+++// ================== Normal method: "logic_or" ===============+// class: "CasADi::SX"+// cppName: "CasADi::SX::logic_or"+// cWrapperName: "CasADi__SX__logic_or"+// protoArgs: "(CasADi::SX* obj, CasADi::SX* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass SX))+// cWrapperRetType: "CasADi::SX*"+// proto: "CasADi::SX* CasADi__SX__logic_or(CasADi::SX* obj, CasADi::SX* x0)"+// call: "obj->logic_or(x0_)"+extern "C"+ CasADi::SX* CasADi__SX__logic_or(CasADi::SX* obj, CasADi::SX* x0);+CasADi::SX* CasADi__SX__logic_or(CasADi::SX* obj, CasADi::SX* x0){+ CasADi::SX x0_ = Marshaling<CasADi::SX,CasADi::SX*>::marshal(x0);++ return new CasADi::SX( obj->logic_or(x0_) );+}+++// ================== Normal method: "if_else_zero" ===============+// class: "CasADi::SX"+// cppName: "CasADi::SX::if_else_zero"+// cWrapperName: "CasADi__SX__if_else_zero"+// protoArgs: "(CasADi::SX* obj, CasADi::SX* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass SX))+// cWrapperRetType: "CasADi::SX*"+// proto: "CasADi::SX* CasADi__SX__if_else_zero(CasADi::SX* obj, CasADi::SX* x0)"+// call: "obj->if_else_zero(x0_)"+extern "C"+ CasADi::SX* CasADi__SX__if_else_zero(CasADi::SX* obj, CasADi::SX* x0);+CasADi::SX* CasADi__SX__if_else_zero(CasADi::SX* obj, CasADi::SX* x0){+ CasADi::SX x0_ = Marshaling<CasADi::SX,CasADi::SX*>::marshal(x0);++ return new CasADi::SX( obj->if_else_zero(x0_) );+}+++// ================== Normal method: "fmin'" ===============+// class: "CasADi::SX"+// cppName: "CasADi::SX::fmin'"+// cWrapperName: "CasADi__SX__fmin_TIC"+// protoArgs: "(CasADi::SX* obj, CasADi::Matrix< CasADi::SX >* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass SXMatrix))+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__SX__fmin_TIC(CasADi::SX* obj, CasADi::Matrix< CasADi::SX >* x0)"+// call: "obj->fmin(x0_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__SX__fmin_TIC(CasADi::SX* obj, CasADi::Matrix< CasADi::SX >* x0);+CasADi::Matrix< CasADi::SX >* CasADi__SX__fmin_TIC(CasADi::SX* obj, CasADi::Matrix< CasADi::SX >* x0){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);++ return new CasADi::Matrix< CasADi::SX >( obj->fmin(x0_) );+}+++// ================== Normal method: "fmax'" ===============+// class: "CasADi::SX"+// cppName: "CasADi::SX::fmax'"+// cWrapperName: "CasADi__SX__fmax_TIC"+// protoArgs: "(CasADi::SX* obj, CasADi::Matrix< CasADi::SX >* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass SXMatrix))+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__SX__fmax_TIC(CasADi::SX* obj, CasADi::Matrix< CasADi::SX >* x0)"+// call: "obj->fmax(x0_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__SX__fmax_TIC(CasADi::SX* obj, CasADi::Matrix< CasADi::SX >* x0);+CasADi::Matrix< CasADi::SX >* CasADi__SX__fmax_TIC(CasADi::SX* obj, CasADi::Matrix< CasADi::SX >* x0){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);++ return new CasADi::Matrix< CasADi::SX >( obj->fmax(x0_) );+}+++// ================== Normal method: "constpow'" ===============+// class: "CasADi::SX"+// cppName: "CasADi::SX::constpow'"+// cWrapperName: "CasADi__SX__constpow_TIC"+// protoArgs: "(CasADi::SX* obj, CasADi::Matrix< CasADi::SX >* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass SXMatrix))+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__SX__constpow_TIC(CasADi::SX* obj, CasADi::Matrix< CasADi::SX >* x0)"+// call: "obj->constpow(x0_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__SX__constpow_TIC(CasADi::SX* obj, CasADi::Matrix< CasADi::SX >* x0);+CasADi::Matrix< CasADi::SX >* CasADi__SX__constpow_TIC(CasADi::SX* obj, CasADi::Matrix< CasADi::SX >* x0){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);++ return new CasADi::Matrix< CasADi::SX >( obj->constpow(x0_) );+}+++// ================== Normal method: "arctan2'" ===============+// class: "CasADi::SX"+// cppName: "CasADi::SX::arctan2'"+// cWrapperName: "CasADi__SX__arctan2_TIC"+// protoArgs: "(CasADi::SX* obj, CasADi::Matrix< CasADi::SX >* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass SXMatrix))+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__SX__arctan2_TIC(CasADi::SX* obj, CasADi::Matrix< CasADi::SX >* x0)"+// call: "obj->arctan2(x0_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__SX__arctan2_TIC(CasADi::SX* obj, CasADi::Matrix< CasADi::SX >* x0);+CasADi::Matrix< CasADi::SX >* CasADi__SX__arctan2_TIC(CasADi::SX* obj, CasADi::Matrix< CasADi::SX >* x0){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);++ return new CasADi::Matrix< CasADi::SX >( obj->arctan2(x0_) );+}+++// ================== Normal method: "getTemp" ===============+// class: "CasADi::SX"+// cppName: "CasADi::SX::getTemp"+// cWrapperName: "CasADi__SX__getTemp"+// protoArgs: "(CasADi::SX* obj)"+// args: "()"+// rettype: Val (NonVec CInt)+// cWrapperRetType: "int"+// proto: "int CasADi__SX__getTemp(CasADi::SX* obj)"+// call: "obj->getTemp()"+extern "C"+ int CasADi__SX__getTemp(CasADi::SX* obj);+int CasADi__SX__getTemp(CasADi::SX* obj){++ return obj->getTemp();+}+++// ================== Normal method: "setTemp" ===============+// class: "CasADi::SX"+// cppName: "CasADi::SX::setTemp"+// cWrapperName: "CasADi__SX__setTemp"+// protoArgs: "(CasADi::SX* obj, int x0)"+// args: "(x0_)"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__SX__setTemp(CasADi::SX* obj, int x0)"+// call: "obj->setTemp(x0_)"+extern "C"+ void CasADi__SX__setTemp(CasADi::SX* obj, int x0);+void CasADi__SX__setTemp(CasADi::SX* obj, int x0){+ int x0_ = Marshaling<int,int>::marshal(x0);++ return obj->setTemp(x0_);+}+++// ================== Normal method: "marked" ===============+// class: "CasADi::SX"+// cppName: "CasADi::SX::marked"+// cWrapperName: "CasADi__SX__marked"+// protoArgs: "(CasADi::SX* obj)"+// args: "()"+// rettype: Val (NonVec CBool)+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__SX__marked(CasADi::SX* obj)"+// call: "obj->marked()"+extern "C"+ bool* CasADi__SX__marked(CasADi::SX* obj);+bool* CasADi__SX__marked(CasADi::SX* obj){++ return new bool( obj->marked() );+}+++// ================== Normal method: "mark" ===============+// class: "CasADi::SX"+// cppName: "CasADi::SX::mark"+// cWrapperName: "CasADi__SX__mark"+// protoArgs: "(CasADi::SX* obj)"+// args: "()"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__SX__mark(CasADi::SX* obj)"+// call: "obj->mark()"+extern "C"+ void CasADi__SX__mark(CasADi::SX* obj);+void CasADi__SX__mark(CasADi::SX* obj){++ return obj->mark();+}+++// ================== Normal method: "assignIfDuplicate" ===============+// class: "CasADi::SX"+// cppName: "CasADi::SX::assignIfDuplicate"+// cWrapperName: "CasADi__SX__assignIfDuplicate"+// protoArgs: "(CasADi::SX* obj, CasADi::SX* x0, int x1)"+// args: "(x0_, x1_)"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__SX__assignIfDuplicate(CasADi::SX* obj, CasADi::SX* x0, int x1)"+// call: "obj->assignIfDuplicate(x0_, x1_)"+extern "C"+ void CasADi__SX__assignIfDuplicate(CasADi::SX* obj, CasADi::SX* x0, int x1);+void CasADi__SX__assignIfDuplicate(CasADi::SX* obj, CasADi::SX* x0, int x1){+ CasADi::SX x0_ = Marshaling<CasADi::SX,CasADi::SX*>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);++ return obj->assignIfDuplicate(x0_, x1_);+}+++// ================== Normal method: "assignIfDuplicate'" ===============+// class: "CasADi::SX"+// cppName: "CasADi::SX::assignIfDuplicate'"+// cWrapperName: "CasADi__SX__assignIfDuplicate_TIC"+// protoArgs: "(CasADi::SX* obj, CasADi::SX* x0)"+// args: "(x0_)"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__SX__assignIfDuplicate_TIC(CasADi::SX* obj, CasADi::SX* x0)"+// call: "obj->assignIfDuplicate(x0_)"+extern "C"+ void CasADi__SX__assignIfDuplicate_TIC(CasADi::SX* obj, CasADi::SX* x0);+void CasADi__SX__assignIfDuplicate_TIC(CasADi::SX* obj, CasADi::SX* x0){+ CasADi::SX x0_ = Marshaling<CasADi::SX,CasADi::SX*>::marshal(x0);++ return obj->assignIfDuplicate(x0_);+}+++// ================== Static method: "setMaxNumCallsInPrint" ===============+// class: "CasADi::SX"+// cppName: "CasADi::SX::setMaxNumCallsInPrint"+// cWrapperName: "CasADi__SX__setMaxNumCallsInPrint"+// protoArgs: "(long x0)"+// args: "(x0_)"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__SX__setMaxNumCallsInPrint(long x0)"+// call: "CasADi::SX::setMaxNumCallsInPrint(x0_)"+extern "C"+ void CasADi__SX__setMaxNumCallsInPrint(long x0);+void CasADi__SX__setMaxNumCallsInPrint(long x0){+ long x0_ = Marshaling<long,long>::marshal(x0);++ return CasADi::SX::setMaxNumCallsInPrint(x0_);+}+++// ================== Static method: "setMaxNumCallsInPrint'" ===============+// class: "CasADi::SX"+// cppName: "CasADi::SX::setMaxNumCallsInPrint'"+// cWrapperName: "CasADi__SX__setMaxNumCallsInPrint_TIC"+// protoArgs: "()"+// args: "()"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__SX__setMaxNumCallsInPrint_TIC()"+// call: "CasADi::SX::setMaxNumCallsInPrint()"+extern "C"+ void CasADi__SX__setMaxNumCallsInPrint_TIC();+void CasADi__SX__setMaxNumCallsInPrint_TIC(){++ return CasADi::SX::setMaxNumCallsInPrint();+}+++// ================== Static method: "getMaxNumCallsInPrint" ===============+// class: "CasADi::SX"+// cppName: "CasADi::SX::getMaxNumCallsInPrint"+// cWrapperName: "CasADi__SX__getMaxNumCallsInPrint"+// protoArgs: "()"+// args: "()"+// rettype: Val (NonVec CLong)+// cWrapperRetType: "long"+// proto: "long CasADi__SX__getMaxNumCallsInPrint()"+// call: "CasADi::SX::getMaxNumCallsInPrint()"+extern "C"+ long CasADi__SX__getMaxNumCallsInPrint();+long CasADi__SX__getMaxNumCallsInPrint(){++ return CasADi::SX::getMaxNumCallsInPrint();+}+++// ================== Static method: "setEqualityCheckingDepth" ===============+// class: "CasADi::SX"+// cppName: "CasADi::SX::setEqualityCheckingDepth"+// cWrapperName: "CasADi__SX__setEqualityCheckingDepth"+// protoArgs: "(int x0)"+// args: "(x0_)"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__SX__setEqualityCheckingDepth(int x0)"+// call: "CasADi::SX::setEqualityCheckingDepth(x0_)"+extern "C"+ void CasADi__SX__setEqualityCheckingDepth(int x0);+void CasADi__SX__setEqualityCheckingDepth(int x0){+ int x0_ = Marshaling<int,int>::marshal(x0);++ return CasADi::SX::setEqualityCheckingDepth(x0_);+}+++// ================== Static method: "setEqualityCheckingDepth'" ===============+// class: "CasADi::SX"+// cppName: "CasADi::SX::setEqualityCheckingDepth'"+// cWrapperName: "CasADi__SX__setEqualityCheckingDepth_TIC"+// protoArgs: "()"+// args: "()"+// rettype: Val (NonVec CVoid)+// cWrapperRetType: "void"+// proto: "void CasADi__SX__setEqualityCheckingDepth_TIC()"+// call: "CasADi::SX::setEqualityCheckingDepth()"+extern "C"+ void CasADi__SX__setEqualityCheckingDepth_TIC();+void CasADi__SX__setEqualityCheckingDepth_TIC(){++ return CasADi::SX::setEqualityCheckingDepth();+}+++// ================== Static method: "getEqualityCheckingDepth" ===============+// class: "CasADi::SX"+// cppName: "CasADi::SX::getEqualityCheckingDepth"+// cWrapperName: "CasADi__SX__getEqualityCheckingDepth"+// protoArgs: "()"+// args: "()"+// rettype: Val (NonVec CInt)+// cWrapperRetType: "int"+// proto: "int CasADi__SX__getEqualityCheckingDepth()"+// call: "CasADi::SX::getEqualityCheckingDepth()"+extern "C"+ int CasADi__SX__getEqualityCheckingDepth();+int CasADi__SX__getEqualityCheckingDepth(){++ return CasADi::SX::getEqualityCheckingDepth();+}+++// ================== Normal method: "isNull" ===============+// class: "CasADi::SX"+// cppName: "CasADi::SX::isNull"+// cWrapperName: "CasADi__SX__isNull"+// protoArgs: "(CasADi::SX* obj)"+// args: "()"+// rettype: Val (NonVec CBool)+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__SX__isNull(CasADi::SX* obj)"+// call: "obj->isNull()"+extern "C"+ bool* CasADi__SX__isNull(CasADi::SX* obj);+bool* CasADi__SX__isNull(CasADi::SX* obj){++ return new bool( obj->isNull() );+}+++// ================== Constructor method: "SX" ===============+// class: "CasADi::SX"+// cppName: "CasADi::SX"+// cWrapperName: "CasADi__SX__SX"+// protoArgs: "()"+// args: "()"+// rettype: Val (NonVec (CasadiClass SX))+// cWrapperRetType: "CasADi::SX*"+// proto: "CasADi::SX* CasADi__SX__SX()"+// call: "CasADi::SX()"+extern "C"+ CasADi::SX* CasADi__SX__SX();+CasADi::SX* CasADi__SX__SX(){++ return new CasADi::SX( CasADi::SX() );+}+++// ================== Constructor method: "SX'" ===============+// class: "CasADi::SX"+// cppName: "CasADi::SX"+// cWrapperName: "CasADi__SX__SX_TIC"+// protoArgs: "(double x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass SX))+// cWrapperRetType: "CasADi::SX*"+// proto: "CasADi::SX* CasADi__SX__SX_TIC(double x0)"+// call: "CasADi::SX(x0_)"+extern "C"+ CasADi::SX* CasADi__SX__SX_TIC(double x0);+CasADi::SX* CasADi__SX__SX_TIC(double x0){+ double x0_ = Marshaling<double,double>::marshal(x0);++ return new CasADi::SX( CasADi::SX(x0_) );+}+++// ================== Constructor method: "SX''" ===============+// class: "CasADi::SX"+// cppName: "CasADi::SX"+// cWrapperName: "CasADi__SX__SX_TIC_TIC"+// protoArgs: "(std::string* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass SX))+// cWrapperRetType: "CasADi::SX*"+// proto: "CasADi::SX* CasADi__SX__SX_TIC_TIC(std::string* x0)"+// call: "CasADi::SX(x0_)"+extern "C"+ CasADi::SX* CasADi__SX__SX_TIC_TIC(std::string* x0);+CasADi::SX* CasADi__SX__SX_TIC_TIC(std::string* x0){+ std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);++ return new CasADi::SX( CasADi::SX(x0_) );+}+++// ================== delete CasadiClass CasadiMeta===============+// classType: CasadiClass CasadiMeta+extern "C"+ void delete_CasADi__CasadiMeta(CasADi::CasadiMeta* obj);+void delete_CasADi__CasadiMeta(CasADi::CasadiMeta* obj){+ delete obj;+}+extern "C"+ void delete_std__vector_CasADi__CasadiMeta_(std::vector<CasADi::CasadiMeta* >* obj);+void delete_std__vector_CasADi__CasadiMeta_(std::vector<CasADi::CasadiMeta* >* obj){+ delete obj;+}+extern "C"+ void delete_std__vector_std__vector_CasADi__CasadiMeta__(std::vector<std::vector<CasADi::CasadiMeta* > >* obj);+void delete_std__vector_std__vector_CasADi__CasadiMeta__(std::vector<std::vector<CasADi::CasadiMeta* > >* obj){+ delete obj;+}+extern "C"+ void delete_std__vector_std__vector_std__vector_CasADi__CasadiMeta___(std::vector<std::vector<std::vector<CasADi::CasadiMeta* > > >* obj);+void delete_std__vector_std__vector_std__vector_CasADi__CasadiMeta___(std::vector<std::vector<std::vector<CasADi::CasadiMeta* > > >* obj){+ delete obj;+}++// ================== Static method: "getVersion" ===============+// class: "CasADi::CasadiMeta"+// cppName: "CasADi::CasadiMeta::getVersion"+// cWrapperName: "CasADi__CasadiMeta__getVersion"+// protoArgs: "()"+// args: "()"+// rettype: Val (NonVec StdString)+// cWrapperRetType: "std::string*"+// proto: "std::string* CasADi__CasadiMeta__getVersion()"+// call: "CasADi::CasadiMeta::getVersion()"+extern "C"+ std::string* CasADi__CasadiMeta__getVersion();+std::string* CasADi__CasadiMeta__getVersion(){++ return new std::string( CasADi::CasadiMeta::getVersion() );+}+++// ================== Static method: "getGitRevision" ===============+// class: "CasADi::CasadiMeta"+// cppName: "CasADi::CasadiMeta::getGitRevision"+// cWrapperName: "CasADi__CasadiMeta__getGitRevision"+// protoArgs: "()"+// args: "()"+// rettype: Val (NonVec StdString)+// cWrapperRetType: "std::string*"+// proto: "std::string* CasADi__CasadiMeta__getGitRevision()"+// call: "CasADi::CasadiMeta::getGitRevision()"+extern "C"+ std::string* CasADi__CasadiMeta__getGitRevision();+std::string* CasADi__CasadiMeta__getGitRevision(){++ return new std::string( CasADi::CasadiMeta::getGitRevision() );+}+++// ================== Static method: "getGitDescribe" ===============+// class: "CasADi::CasadiMeta"+// cppName: "CasADi::CasadiMeta::getGitDescribe"+// cWrapperName: "CasADi__CasadiMeta__getGitDescribe"+// protoArgs: "()"+// args: "()"+// rettype: Val (NonVec StdString)+// cWrapperRetType: "std::string*"+// proto: "std::string* CasADi__CasadiMeta__getGitDescribe()"+// call: "CasADi::CasadiMeta::getGitDescribe()"+extern "C"+ std::string* CasADi__CasadiMeta__getGitDescribe();+std::string* CasADi__CasadiMeta__getGitDescribe(){++ return new std::string( CasADi::CasadiMeta::getGitDescribe() );+}+++// ================== Static method: "getFeatureList" ===============+// class: "CasADi::CasadiMeta"+// cppName: "CasADi::CasadiMeta::getFeatureList"+// cWrapperName: "CasADi__CasadiMeta__getFeatureList"+// protoArgs: "()"+// args: "()"+// rettype: Val (NonVec StdString)+// cWrapperRetType: "std::string*"+// proto: "std::string* CasADi__CasadiMeta__getFeatureList()"+// call: "CasADi::CasadiMeta::getFeatureList()"+extern "C"+ std::string* CasADi__CasadiMeta__getFeatureList();+std::string* CasADi__CasadiMeta__getFeatureList(){++ return new std::string( CasADi::CasadiMeta::getFeatureList() );+}+++// ================== Static method: "getBuildType" ===============+// class: "CasADi::CasadiMeta"+// cppName: "CasADi::CasadiMeta::getBuildType"+// cWrapperName: "CasADi__CasadiMeta__getBuildType"+// protoArgs: "()"+// args: "()"+// rettype: Val (NonVec StdString)+// cWrapperRetType: "std::string*"+// proto: "std::string* CasADi__CasadiMeta__getBuildType()"+// call: "CasADi::CasadiMeta::getBuildType()"+extern "C"+ std::string* CasADi__CasadiMeta__getBuildType();+std::string* CasADi__CasadiMeta__getBuildType(){++ return new std::string( CasADi::CasadiMeta::getBuildType() );+}+++// ================== Static method: "getCompilerId" ===============+// class: "CasADi::CasadiMeta"+// cppName: "CasADi::CasadiMeta::getCompilerId"+// cWrapperName: "CasADi__CasadiMeta__getCompilerId"+// protoArgs: "()"+// args: "()"+// rettype: Val (NonVec StdString)+// cWrapperRetType: "std::string*"+// proto: "std::string* CasADi__CasadiMeta__getCompilerId()"+// call: "CasADi::CasadiMeta::getCompilerId()"+extern "C"+ std::string* CasADi__CasadiMeta__getCompilerId();+std::string* CasADi__CasadiMeta__getCompilerId(){++ return new std::string( CasADi::CasadiMeta::getCompilerId() );+}+++// ================== Static method: "getCompiler" ===============+// class: "CasADi::CasadiMeta"+// cppName: "CasADi::CasadiMeta::getCompiler"+// cWrapperName: "CasADi__CasadiMeta__getCompiler"+// protoArgs: "()"+// args: "()"+// rettype: Val (NonVec StdString)+// cWrapperRetType: "std::string*"+// proto: "std::string* CasADi__CasadiMeta__getCompiler()"+// call: "CasADi::CasadiMeta::getCompiler()"+extern "C"+ std::string* CasADi__CasadiMeta__getCompiler();+std::string* CasADi__CasadiMeta__getCompiler(){++ return new std::string( CasADi::CasadiMeta::getCompiler() );+}+++// ================== Static method: "getCompilerFlags" ===============+// class: "CasADi::CasadiMeta"+// cppName: "CasADi::CasadiMeta::getCompilerFlags"+// cWrapperName: "CasADi__CasadiMeta__getCompilerFlags"+// protoArgs: "()"+// args: "()"+// rettype: Val (NonVec StdString)+// cWrapperRetType: "std::string*"+// proto: "std::string* CasADi__CasadiMeta__getCompilerFlags()"+// call: "CasADi::CasadiMeta::getCompilerFlags()"+extern "C"+ std::string* CasADi__CasadiMeta__getCompilerFlags();+std::string* CasADi__CasadiMeta__getCompilerFlags(){++ return new std::string( CasADi::CasadiMeta::getCompilerFlags() );+}+++// ================== delete CasadiClass Functor===============+// classType: CasadiClass Functor+extern "C"+ void delete_CasADi__Functor(CasADi::Functor* obj);+void delete_CasADi__Functor(CasADi::Functor* obj){+ delete obj;+}+extern "C"+ void delete_std__vector_CasADi__Functor_(std::vector<CasADi::Functor* >* obj);+void delete_std__vector_CasADi__Functor_(std::vector<CasADi::Functor* >* obj){+ delete obj;+}+extern "C"+ void delete_std__vector_std__vector_CasADi__Functor__(std::vector<std::vector<CasADi::Functor* > >* obj);+void delete_std__vector_std__vector_CasADi__Functor__(std::vector<std::vector<CasADi::Functor* > >* obj){+ delete obj;+}+extern "C"+ void delete_std__vector_std__vector_std__vector_CasADi__Functor___(std::vector<std::vector<std::vector<CasADi::Functor* > > >* obj);+void delete_std__vector_std__vector_std__vector_CasADi__Functor___(std::vector<std::vector<std::vector<CasADi::Functor* > > >* obj){+ delete obj;+}++// ================== delete CasadiClass CustomFunction===============+// classType: CasadiClass CustomFunction+extern "C"+ void delete_CasADi__CustomFunction(CasADi::CustomFunction* obj);+void delete_CasADi__CustomFunction(CasADi::CustomFunction* obj){+ delete obj;+}+extern "C"+ void delete_std__vector_CasADi__CustomFunction_(std::vector<CasADi::CustomFunction* >* obj);+void delete_std__vector_CasADi__CustomFunction_(std::vector<CasADi::CustomFunction* >* obj){+ delete obj;+}+extern "C"+ void delete_std__vector_std__vector_CasADi__CustomFunction__(std::vector<std::vector<CasADi::CustomFunction* > >* obj);+void delete_std__vector_std__vector_CasADi__CustomFunction__(std::vector<std::vector<CasADi::CustomFunction* > >* obj){+ delete obj;+}+extern "C"+ void delete_std__vector_std__vector_std__vector_CasADi__CustomFunction___(std::vector<std::vector<std::vector<CasADi::CustomFunction* > > >* obj);+void delete_std__vector_std__vector_std__vector_CasADi__CustomFunction___(std::vector<std::vector<std::vector<CasADi::CustomFunction* > > >* obj){+ delete obj;+}++// ================== Normal method: "checkNode" ===============+// class: "CasADi::CustomFunction"+// cppName: "CasADi::CustomFunction::checkNode"+// cWrapperName: "CasADi__CustomFunction__checkNode"+// protoArgs: "(CasADi::CustomFunction* obj)"+// args: "()"+// rettype: Val (NonVec CBool)+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__CustomFunction__checkNode(CasADi::CustomFunction* obj)"+// call: "obj->checkNode()"+extern "C"+ bool* CasADi__CustomFunction__checkNode(CasADi::CustomFunction* obj);+bool* CasADi__CustomFunction__checkNode(CasADi::CustomFunction* obj){++ return new bool( obj->checkNode() );+}+++// ================== Constructor method: "CustomFunction" ===============+// class: "CasADi::CustomFunction"+// cppName: "CasADi::CustomFunction"+// cWrapperName: "CasADi__CustomFunction__CustomFunction"+// protoArgs: "()"+// args: "()"+// rettype: Val (NonVec (CasadiClass CustomFunction))+// cWrapperRetType: "CasADi::CustomFunction*"+// proto: "CasADi::CustomFunction* CasADi__CustomFunction__CustomFunction()"+// call: "CasADi::CustomFunction()"+extern "C"+ CasADi::CustomFunction* CasADi__CustomFunction__CustomFunction();+CasADi::CustomFunction* CasADi__CustomFunction__CustomFunction(){++ return new CasADi::CustomFunction( CasADi::CustomFunction() );+}+++// ================== Constructor method: "CustomFunction'" ===============+// class: "CasADi::CustomFunction"+// cppName: "CasADi::CustomFunction"+// cWrapperName: "CasADi__CustomFunction__CustomFunction_TIC"+// protoArgs: "(CasADi::CustomEvaluate* x0, std::vector<CasADi::CRSSparsity* > * x1, std::vector<CasADi::CRSSparsity* > * x2)"+// args: "(x0_, x1_, x2_)"+// rettype: Val (NonVec (CasadiClass CustomFunction))+// cWrapperRetType: "CasADi::CustomFunction*"+// proto: "CasADi::CustomFunction* CasADi__CustomFunction__CustomFunction_TIC(CasADi::CustomEvaluate* x0, std::vector<CasADi::CRSSparsity* > * x1, std::vector<CasADi::CRSSparsity* > * x2)"+// call: "CasADi::CustomFunction(x0_, x1_, x2_)"+extern "C"+ CasADi::CustomFunction* CasADi__CustomFunction__CustomFunction_TIC(CasADi::CustomEvaluate* x0, std::vector<CasADi::CRSSparsity* > * x1, std::vector<CasADi::CRSSparsity* > * x2);+CasADi::CustomFunction* CasADi__CustomFunction__CustomFunction_TIC(CasADi::CustomEvaluate* x0, std::vector<CasADi::CRSSparsity* > * x1, std::vector<CasADi::CRSSparsity* > * x2){+ CasADi::CustomEvaluate x0_ = Marshaling<CasADi::CustomEvaluate,CasADi::CustomEvaluate*>::marshal(x0);+ std::vector<CasADi::CRSSparsity > x1_ = Marshaling<std::vector<CasADi::CRSSparsity >,std::vector<CasADi::CRSSparsity* > *>::marshal(x1);+ std::vector<CasADi::CRSSparsity > x2_ = Marshaling<std::vector<CasADi::CRSSparsity >,std::vector<CasADi::CRSSparsity* > *>::marshal(x2);++ return new CasADi::CustomFunction( CasADi::CustomFunction(x0_, x1_, x2_) );+}+++// ================== Constructor method: "CustomFunction'''''" ===============+// class: "CasADi::CustomFunction"+// cppName: "CasADi::CustomFunction"+// cWrapperName: "CasADi__CustomFunction__CustomFunction_TIC_TIC_TIC_TIC_TIC"+// protoArgs: "(CasADi::CustomEvaluate* x0)"+// args: "(x0_)"+// rettype: Val (NonVec (CasadiClass CustomFunction))+// cWrapperRetType: "CasADi::CustomFunction*"+// proto: "CasADi::CustomFunction* CasADi__CustomFunction__CustomFunction_TIC_TIC_TIC_TIC_TIC(CasADi::CustomEvaluate* x0)"+// call: "CasADi::CustomFunction(x0_)"+extern "C"+ CasADi::CustomFunction* CasADi__CustomFunction__CustomFunction_TIC_TIC_TIC_TIC_TIC(CasADi::CustomEvaluate* x0);+CasADi::CustomFunction* CasADi__CustomFunction__CustomFunction_TIC_TIC_TIC_TIC_TIC(CasADi::CustomEvaluate* x0){+ CasADi::CustomEvaluate x0_ = Marshaling<CasADi::CustomEvaluate,CasADi::CustomEvaluate*>::marshal(x0);++ return new CasADi::CustomFunction( CasADi::CustomFunction(x0_) );+}+++// ================== function "CasADi::getSchemeEntryName" ===============+// cppName: "CasADi::getSchemeEntryName"+// cWrapperName: "CasADi__getSchemeEntryName"+// protoArgs: "(CasADi::InputOutputScheme x0, int x1)"+// params: [Val (NonVec (CasadiEnum InputOutputScheme)),Val (NonVec CInt)]+// args: "(x0_, x1_)"+// cWrapperRetType: "std::string*"+// proto: "std::string* CasADi__getSchemeEntryName(CasADi::InputOutputScheme x0, int x1)"+// call: "CasADi::getSchemeEntryName(x0_, x1_)"+extern "C"+ std::string* CasADi__getSchemeEntryName(CasADi::InputOutputScheme x0, int x1);+std::string* CasADi__getSchemeEntryName(CasADi::InputOutputScheme x0, int x1){+ CasADi::InputOutputScheme x0_ = Marshaling<CasADi::InputOutputScheme,CasADi::InputOutputScheme>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);++ return new std::string( CasADi::getSchemeEntryName(x0_, x1_) );+}+++// ================== function "CasADi::getSchemeEntryDoc" ===============+// cppName: "CasADi::getSchemeEntryDoc"+// cWrapperName: "CasADi__getSchemeEntryDoc"+// protoArgs: "(CasADi::InputOutputScheme x0, int x1)"+// params: [Val (NonVec (CasadiEnum InputOutputScheme)),Val (NonVec CInt)]+// args: "(x0_, x1_)"+// cWrapperRetType: "std::string*"+// proto: "std::string* CasADi__getSchemeEntryDoc(CasADi::InputOutputScheme x0, int x1)"+// call: "CasADi::getSchemeEntryDoc(x0_, x1_)"+extern "C"+ std::string* CasADi__getSchemeEntryDoc(CasADi::InputOutputScheme x0, int x1);+std::string* CasADi__getSchemeEntryDoc(CasADi::InputOutputScheme x0, int x1){+ CasADi::InputOutputScheme x0_ = Marshaling<CasADi::InputOutputScheme,CasADi::InputOutputScheme>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);++ return new std::string( CasADi::getSchemeEntryDoc(x0_, x1_) );+}+++// ================== function "CasADi::getSchemeEntryEnumName" ===============+// cppName: "CasADi::getSchemeEntryEnumName"+// cWrapperName: "CasADi__getSchemeEntryEnumName"+// protoArgs: "(CasADi::InputOutputScheme x0, int x1)"+// params: [Val (NonVec (CasadiEnum InputOutputScheme)),Val (NonVec CInt)]+// args: "(x0_, x1_)"+// cWrapperRetType: "std::string*"+// proto: "std::string* CasADi__getSchemeEntryEnumName(CasADi::InputOutputScheme x0, int x1)"+// call: "CasADi::getSchemeEntryEnumName(x0_, x1_)"+extern "C"+ std::string* CasADi__getSchemeEntryEnumName(CasADi::InputOutputScheme x0, int x1);+std::string* CasADi__getSchemeEntryEnumName(CasADi::InputOutputScheme x0, int x1){+ CasADi::InputOutputScheme x0_ = Marshaling<CasADi::InputOutputScheme,CasADi::InputOutputScheme>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);++ return new std::string( CasADi::getSchemeEntryEnumName(x0_, x1_) );+}+++// ================== function "CasADi::getSchemeEntryEnum" ===============+// cppName: "CasADi::getSchemeEntryEnum"+// cWrapperName: "CasADi__getSchemeEntryEnum"+// protoArgs: "(CasADi::InputOutputScheme x0, std::string* x1)"+// params: [Val (NonVec (CasadiEnum InputOutputScheme)),ConstRef (NonVec StdString)]+// args: "(x0_, x1_)"+// cWrapperRetType: "int"+// proto: "int CasADi__getSchemeEntryEnum(CasADi::InputOutputScheme x0, std::string* x1)"+// call: "CasADi::getSchemeEntryEnum(x0_, x1_)"+extern "C"+ int CasADi__getSchemeEntryEnum(CasADi::InputOutputScheme x0, std::string* x1);+int CasADi__getSchemeEntryEnum(CasADi::InputOutputScheme x0, std::string* x1){+ CasADi::InputOutputScheme x0_ = Marshaling<CasADi::InputOutputScheme,CasADi::InputOutputScheme>::marshal(x0);+ std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);++ return CasADi::getSchemeEntryEnum(x0_, x1_);+}+++// ================== function "CasADi::getSchemeSize" ===============+// cppName: "CasADi::getSchemeSize"+// cWrapperName: "CasADi__getSchemeSize"+// protoArgs: "(CasADi::InputOutputScheme x0)"+// params: [Val (NonVec (CasadiEnum InputOutputScheme))]+// args: "(x0_)"+// cWrapperRetType: "int"+// proto: "int CasADi__getSchemeSize(CasADi::InputOutputScheme x0)"+// call: "CasADi::getSchemeSize(x0_)"+extern "C"+ int CasADi__getSchemeSize(CasADi::InputOutputScheme x0);+int CasADi__getSchemeSize(CasADi::InputOutputScheme x0){+ CasADi::InputOutputScheme x0_ = Marshaling<CasADi::InputOutputScheme,CasADi::InputOutputScheme>::marshal(x0);++ return CasADi::getSchemeSize(x0_);+}+++// ================== function "CasADi::getSchemeName" ===============+// cppName: "CasADi::getSchemeName"+// cWrapperName: "CasADi__getSchemeName"+// protoArgs: "(CasADi::InputOutputScheme x0)"+// params: [Val (NonVec (CasadiEnum InputOutputScheme))]+// args: "(x0_)"+// cWrapperRetType: "std::string*"+// proto: "std::string* CasADi__getSchemeName(CasADi::InputOutputScheme x0)"+// call: "CasADi::getSchemeName(x0_)"+extern "C"+ std::string* CasADi__getSchemeName(CasADi::InputOutputScheme x0);+std::string* CasADi__getSchemeName(CasADi::InputOutputScheme x0){+ CasADi::InputOutputScheme x0_ = Marshaling<CasADi::InputOutputScheme,CasADi::InputOutputScheme>::marshal(x0);++ return new std::string( CasADi::getSchemeName(x0_) );+}+++// ================== function "CasADi::getSchemeEntryNames" ===============+// cppName: "CasADi::getSchemeEntryNames"+// cWrapperName: "CasADi__getSchemeEntryNames"+// protoArgs: "(CasADi::InputOutputScheme x0)"+// params: [Val (NonVec (CasadiEnum InputOutputScheme))]+// args: "(x0_)"+// cWrapperRetType: "std::string*"+// proto: "std::string* CasADi__getSchemeEntryNames(CasADi::InputOutputScheme x0)"+// call: "CasADi::getSchemeEntryNames(x0_)"+extern "C"+ std::string* CasADi__getSchemeEntryNames(CasADi::InputOutputScheme x0);+std::string* CasADi__getSchemeEntryNames(CasADi::InputOutputScheme x0){+ CasADi::InputOutputScheme x0_ = Marshaling<CasADi::InputOutputScheme,CasADi::InputOutputScheme>::marshal(x0);++ return new std::string( CasADi::getSchemeEntryNames(x0_) );+}+++// ================== function "CasADi::complement" ===============+// cppName: "CasADi::complement"+// cWrapperName: "CasADi__complement"+// protoArgs: "(std::vector<int > * x0, int x1)"+// params: [ConstRef (Vec (NonVec CInt)),Val (NonVec CInt)]+// args: "(x0_, x1_)"+// cWrapperRetType: "std::vector<int >*"+// proto: "std::vector<int >* CasADi__complement(std::vector<int > * x0, int x1)"+// call: "CasADi::complement(x0_, x1_)"+extern "C"+ std::vector<int >* CasADi__complement(std::vector<int > * x0, int x1);+std::vector<int >* CasADi__complement(std::vector<int > * x0, int x1){+ std::vector<int > x0_ = Marshaling<std::vector<int >,std::vector<int > *>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);++ return new std::vector<int >( CasADi::complement(x0_, x1_) );+}+++// ================== function "CasADi::lookupvector" ===============+// cppName: "CasADi::lookupvector"+// cWrapperName: "CasADi__lookupvector"+// protoArgs: "(std::vector<int > * x0, int x1)"+// params: [ConstRef (Vec (NonVec CInt)),Val (NonVec CInt)]+// args: "(x0_, x1_)"+// cWrapperRetType: "std::vector<int >*"+// proto: "std::vector<int >* CasADi__lookupvector(std::vector<int > * x0, int x1)"+// call: "CasADi::lookupvector(x0_, x1_)"+extern "C"+ std::vector<int >* CasADi__lookupvector(std::vector<int > * x0, int x1);+std::vector<int >* CasADi__lookupvector(std::vector<int > * x0, int x1){+ std::vector<int > x0_ = Marshaling<std::vector<int >,std::vector<int > *>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);++ return new std::vector<int >( CasADi::lookupvector(x0_, x1_) );+}+++// ================== function "CasADi::isIncreasing" ===============+// cppName: "CasADi::isIncreasing"+// cWrapperName: "CasADi__isIncreasing"+// protoArgs: "(std::vector<int > * x0)"+// params: [ConstRef (Vec (NonVec CInt))]+// args: "(x0_)"+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__isIncreasing(std::vector<int > * x0)"+// call: "CasADi::isIncreasing(x0_)"+extern "C"+ bool* CasADi__isIncreasing(std::vector<int > * x0);+bool* CasADi__isIncreasing(std::vector<int > * x0){+ std::vector<int > x0_ = Marshaling<std::vector<int >,std::vector<int > *>::marshal(x0);++ return new bool( CasADi::isIncreasing(x0_) );+}+++// ================== function "CasADi::isDecreasing" ===============+// cppName: "CasADi::isDecreasing"+// cWrapperName: "CasADi__isDecreasing"+// protoArgs: "(std::vector<int > * x0)"+// params: [ConstRef (Vec (NonVec CInt))]+// args: "(x0_)"+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__isDecreasing(std::vector<int > * x0)"+// call: "CasADi::isDecreasing(x0_)"+extern "C"+ bool* CasADi__isDecreasing(std::vector<int > * x0);+bool* CasADi__isDecreasing(std::vector<int > * x0){+ std::vector<int > x0_ = Marshaling<std::vector<int >,std::vector<int > *>::marshal(x0);++ return new bool( CasADi::isDecreasing(x0_) );+}+++// ================== function "CasADi::isNonIncreasing" ===============+// cppName: "CasADi::isNonIncreasing"+// cWrapperName: "CasADi__isNonIncreasing"+// protoArgs: "(std::vector<int > * x0)"+// params: [ConstRef (Vec (NonVec CInt))]+// args: "(x0_)"+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__isNonIncreasing(std::vector<int > * x0)"+// call: "CasADi::isNonIncreasing(x0_)"+extern "C"+ bool* CasADi__isNonIncreasing(std::vector<int > * x0);+bool* CasADi__isNonIncreasing(std::vector<int > * x0){+ std::vector<int > x0_ = Marshaling<std::vector<int >,std::vector<int > *>::marshal(x0);++ return new bool( CasADi::isNonIncreasing(x0_) );+}+++// ================== function "CasADi::isNonDecreasing" ===============+// cppName: "CasADi::isNonDecreasing"+// cWrapperName: "CasADi__isNonDecreasing"+// protoArgs: "(std::vector<int > * x0)"+// params: [ConstRef (Vec (NonVec CInt))]+// args: "(x0_)"+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__isNonDecreasing(std::vector<int > * x0)"+// call: "CasADi::isNonDecreasing(x0_)"+extern "C"+ bool* CasADi__isNonDecreasing(std::vector<int > * x0);+bool* CasADi__isNonDecreasing(std::vector<int > * x0){+ std::vector<int > x0_ = Marshaling<std::vector<int >,std::vector<int > *>::marshal(x0);++ return new bool( CasADi::isNonDecreasing(x0_) );+}+++// ================== function "CasADi::isMonotone" ===============+// cppName: "CasADi::isMonotone"+// cWrapperName: "CasADi__isMonotone"+// protoArgs: "(std::vector<int > * x0)"+// params: [ConstRef (Vec (NonVec CInt))]+// args: "(x0_)"+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__isMonotone(std::vector<int > * x0)"+// call: "CasADi::isMonotone(x0_)"+extern "C"+ bool* CasADi__isMonotone(std::vector<int > * x0);+bool* CasADi__isMonotone(std::vector<int > * x0){+ std::vector<int > x0_ = Marshaling<std::vector<int >,std::vector<int > *>::marshal(x0);++ return new bool( CasADi::isMonotone(x0_) );+}+++// ================== function "CasADi::isStrictlyMonotone" ===============+// cppName: "CasADi::isStrictlyMonotone"+// cWrapperName: "CasADi__isStrictlyMonotone"+// protoArgs: "(std::vector<int > * x0)"+// params: [ConstRef (Vec (NonVec CInt))]+// args: "(x0_)"+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__isStrictlyMonotone(std::vector<int > * x0)"+// call: "CasADi::isStrictlyMonotone(x0_)"+extern "C"+ bool* CasADi__isStrictlyMonotone(std::vector<int > * x0);+bool* CasADi__isStrictlyMonotone(std::vector<int > * x0){+ std::vector<int > x0_ = Marshaling<std::vector<int >,std::vector<int > *>::marshal(x0);++ return new bool( CasADi::isStrictlyMonotone(x0_) );+}+++// ================== function "CasADi::isRegular" ===============+// cppName: "CasADi::isRegular"+// cWrapperName: "CasADi__isRegular"+// protoArgs: "(std::vector<int > * x0)"+// params: [ConstRef (Vec (NonVec CInt))]+// args: "(x0_)"+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__isRegular(std::vector<int > * x0)"+// call: "CasADi::isRegular(x0_)"+extern "C"+ bool* CasADi__isRegular(std::vector<int > * x0);+bool* CasADi__isRegular(std::vector<int > * x0){+ std::vector<int > x0_ = Marshaling<std::vector<int >,std::vector<int > *>::marshal(x0);++ return new bool( CasADi::isRegular(x0_) );+}+++// ================== function "CasADi::isIncreasing'" ===============+// cppName: "CasADi::isIncreasing'"+// cWrapperName: "CasADi__isIncreasing_TIC"+// protoArgs: "(std::vector<double > * x0)"+// params: [ConstRef (Vec (NonVec CDouble))]+// args: "(x0_)"+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__isIncreasing_TIC(std::vector<double > * x0)"+// call: "CasADi::isIncreasing(x0_)"+extern "C"+ bool* CasADi__isIncreasing_TIC(std::vector<double > * x0);+bool* CasADi__isIncreasing_TIC(std::vector<double > * x0){+ std::vector<double > x0_ = Marshaling<std::vector<double >,std::vector<double > *>::marshal(x0);++ return new bool( CasADi::isIncreasing(x0_) );+}+++// ================== function "CasADi::isDecreasing'" ===============+// cppName: "CasADi::isDecreasing'"+// cWrapperName: "CasADi__isDecreasing_TIC"+// protoArgs: "(std::vector<double > * x0)"+// params: [ConstRef (Vec (NonVec CDouble))]+// args: "(x0_)"+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__isDecreasing_TIC(std::vector<double > * x0)"+// call: "CasADi::isDecreasing(x0_)"+extern "C"+ bool* CasADi__isDecreasing_TIC(std::vector<double > * x0);+bool* CasADi__isDecreasing_TIC(std::vector<double > * x0){+ std::vector<double > x0_ = Marshaling<std::vector<double >,std::vector<double > *>::marshal(x0);++ return new bool( CasADi::isDecreasing(x0_) );+}+++// ================== function "CasADi::isNonIncreasing'" ===============+// cppName: "CasADi::isNonIncreasing'"+// cWrapperName: "CasADi__isNonIncreasing_TIC"+// protoArgs: "(std::vector<double > * x0)"+// params: [ConstRef (Vec (NonVec CDouble))]+// args: "(x0_)"+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__isNonIncreasing_TIC(std::vector<double > * x0)"+// call: "CasADi::isNonIncreasing(x0_)"+extern "C"+ bool* CasADi__isNonIncreasing_TIC(std::vector<double > * x0);+bool* CasADi__isNonIncreasing_TIC(std::vector<double > * x0){+ std::vector<double > x0_ = Marshaling<std::vector<double >,std::vector<double > *>::marshal(x0);++ return new bool( CasADi::isNonIncreasing(x0_) );+}+++// ================== function "CasADi::isNonDecreasing'" ===============+// cppName: "CasADi::isNonDecreasing'"+// cWrapperName: "CasADi__isNonDecreasing_TIC"+// protoArgs: "(std::vector<double > * x0)"+// params: [ConstRef (Vec (NonVec CDouble))]+// args: "(x0_)"+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__isNonDecreasing_TIC(std::vector<double > * x0)"+// call: "CasADi::isNonDecreasing(x0_)"+extern "C"+ bool* CasADi__isNonDecreasing_TIC(std::vector<double > * x0);+bool* CasADi__isNonDecreasing_TIC(std::vector<double > * x0){+ std::vector<double > x0_ = Marshaling<std::vector<double >,std::vector<double > *>::marshal(x0);++ return new bool( CasADi::isNonDecreasing(x0_) );+}+++// ================== function "CasADi::isMonotone'" ===============+// cppName: "CasADi::isMonotone'"+// cWrapperName: "CasADi__isMonotone_TIC"+// protoArgs: "(std::vector<double > * x0)"+// params: [ConstRef (Vec (NonVec CDouble))]+// args: "(x0_)"+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__isMonotone_TIC(std::vector<double > * x0)"+// call: "CasADi::isMonotone(x0_)"+extern "C"+ bool* CasADi__isMonotone_TIC(std::vector<double > * x0);+bool* CasADi__isMonotone_TIC(std::vector<double > * x0){+ std::vector<double > x0_ = Marshaling<std::vector<double >,std::vector<double > *>::marshal(x0);++ return new bool( CasADi::isMonotone(x0_) );+}+++// ================== function "CasADi::isStrictlyMonotone'" ===============+// cppName: "CasADi::isStrictlyMonotone'"+// cWrapperName: "CasADi__isStrictlyMonotone_TIC"+// protoArgs: "(std::vector<double > * x0)"+// params: [ConstRef (Vec (NonVec CDouble))]+// args: "(x0_)"+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__isStrictlyMonotone_TIC(std::vector<double > * x0)"+// call: "CasADi::isStrictlyMonotone(x0_)"+extern "C"+ bool* CasADi__isStrictlyMonotone_TIC(std::vector<double > * x0);+bool* CasADi__isStrictlyMonotone_TIC(std::vector<double > * x0){+ std::vector<double > x0_ = Marshaling<std::vector<double >,std::vector<double > *>::marshal(x0);++ return new bool( CasADi::isStrictlyMonotone(x0_) );+}+++// ================== function "CasADi::isRegular'" ===============+// cppName: "CasADi::isRegular'"+// cWrapperName: "CasADi__isRegular_TIC"+// protoArgs: "(std::vector<double > * x0)"+// params: [ConstRef (Vec (NonVec CDouble))]+// args: "(x0_)"+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__isRegular_TIC(std::vector<double > * x0)"+// call: "CasADi::isRegular(x0_)"+extern "C"+ bool* CasADi__isRegular_TIC(std::vector<double > * x0);+bool* CasADi__isRegular_TIC(std::vector<double > * x0){+ std::vector<double > x0_ = Marshaling<std::vector<double >,std::vector<double > *>::marshal(x0);++ return new bool( CasADi::isRegular(x0_) );+}+++// ================== function "CasADi::isRegular'''" ===============+// cppName: "CasADi::isRegular'''"+// cWrapperName: "CasADi__isRegular_TIC_TIC_TIC"+// protoArgs: "(CasADi::Matrix< double >* x0)"+// params: [ConstRef (NonVec (CasadiClass DMatrix))]+// args: "(x0_)"+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__isRegular_TIC_TIC_TIC(CasADi::Matrix< double >* x0)"+// call: "CasADi::isRegular(x0_)"+extern "C"+ bool* CasADi__isRegular_TIC_TIC_TIC(CasADi::Matrix< double >* x0);+bool* CasADi__isRegular_TIC_TIC_TIC(CasADi::Matrix< double >* x0){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);++ return new bool( CasADi::isRegular(x0_) );+}+++// ================== function "CasADi::trans'" ===============+// cppName: "CasADi::trans'"+// cWrapperName: "CasADi__trans_TIC"+// protoArgs: "(CasADi::Matrix< double >* x0)"+// params: [ConstRef (NonVec (CasadiClass DMatrix))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__trans_TIC(CasADi::Matrix< double >* x0)"+// call: "CasADi::trans(x0_)"+extern "C"+ CasADi::Matrix< double >* CasADi__trans_TIC(CasADi::Matrix< double >* x0);+CasADi::Matrix< double >* CasADi__trans_TIC(CasADi::Matrix< double >* x0){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);++ return new CasADi::Matrix< double >( CasADi::trans(x0_) );+}+++// ================== function "CasADi::mul'''" ===============+// cppName: "CasADi::mul'''"+// cWrapperName: "CasADi__mul_TIC_TIC_TIC"+// protoArgs: "(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1, CasADi::CRSSparsity* x2)"+// params: [ConstRef (NonVec (CasadiClass DMatrix)),ConstRef (NonVec (CasadiClass DMatrix)),ConstRef (NonVec (CasadiClass CRSSparsity))]+// args: "(x0_, x1_, x2_)"+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__mul_TIC_TIC_TIC(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1, CasADi::CRSSparsity* x2)"+// call: "CasADi::mul(x0_, x1_, x2_)"+extern "C"+ CasADi::Matrix< double >* CasADi__mul_TIC_TIC_TIC(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1, CasADi::CRSSparsity* x2);+CasADi::Matrix< double >* CasADi__mul_TIC_TIC_TIC(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1, CasADi::CRSSparsity* x2){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);+ CasADi::Matrix< double > x1_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x1);+ CasADi::CRSSparsity x2_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x2);++ return new CasADi::Matrix< double >( CasADi::mul(x0_, x1_, x2_) );+}+++// ================== function "CasADi::mul''''" ===============+// cppName: "CasADi::mul''''"+// cWrapperName: "CasADi__mul_TIC_TIC_TIC_TIC"+// protoArgs: "(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1)"+// params: [ConstRef (NonVec (CasadiClass DMatrix)),ConstRef (NonVec (CasadiClass DMatrix))]+// args: "(x0_, x1_)"+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__mul_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1)"+// call: "CasADi::mul(x0_, x1_)"+extern "C"+ CasADi::Matrix< double >* CasADi__mul_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1);+CasADi::Matrix< double >* CasADi__mul_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);+ CasADi::Matrix< double > x1_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x1);++ return new CasADi::Matrix< double >( CasADi::mul(x0_, x1_) );+}+++// ================== function "CasADi::mul'''''" ===============+// cppName: "CasADi::mul'''''"+// cWrapperName: "CasADi__mul_TIC_TIC_TIC_TIC_TIC"+// protoArgs: "(std::vector<CasADi::Matrix< double >* > * x0)"+// params: [ConstRef (Vec (NonVec (CasadiClass DMatrix)))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__mul_TIC_TIC_TIC_TIC_TIC(std::vector<CasADi::Matrix< double >* > * x0)"+// call: "CasADi::mul(x0_)"+extern "C"+ CasADi::Matrix< double >* CasADi__mul_TIC_TIC_TIC_TIC_TIC(std::vector<CasADi::Matrix< double >* > * x0);+CasADi::Matrix< double >* CasADi__mul_TIC_TIC_TIC_TIC_TIC(std::vector<CasADi::Matrix< double >* > * x0){+ std::vector<CasADi::Matrix< double > > x0_ = Marshaling<std::vector<CasADi::Matrix< double > >,std::vector<CasADi::Matrix< double >* > *>::marshal(x0);++ return new CasADi::Matrix< double >( CasADi::mul(x0_) );+}+++// ================== function "CasADi::isConstant'" ===============+// cppName: "CasADi::isConstant'"+// cWrapperName: "CasADi__isConstant_TIC"+// protoArgs: "(CasADi::Matrix< double >* x0)"+// params: [ConstRef (NonVec (CasadiClass DMatrix))]+// args: "(x0_)"+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__isConstant_TIC(CasADi::Matrix< double >* x0)"+// call: "CasADi::isConstant(x0_)"+extern "C"+ bool* CasADi__isConstant_TIC(CasADi::Matrix< double >* x0);+bool* CasADi__isConstant_TIC(CasADi::Matrix< double >* x0){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);++ return new bool( CasADi::isConstant(x0_) );+}+++// ================== function "CasADi::isDense'" ===============+// cppName: "CasADi::isDense'"+// cWrapperName: "CasADi__isDense_TIC"+// protoArgs: "(CasADi::Matrix< double >* x0)"+// params: [ConstRef (NonVec (CasadiClass DMatrix))]+// args: "(x0_)"+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__isDense_TIC(CasADi::Matrix< double >* x0)"+// call: "CasADi::isDense(x0_)"+extern "C"+ bool* CasADi__isDense_TIC(CasADi::Matrix< double >* x0);+bool* CasADi__isDense_TIC(CasADi::Matrix< double >* x0){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);++ return new bool( CasADi::isDense(x0_) );+}+++// ================== function "CasADi::isEmpty'" ===============+// cppName: "CasADi::isEmpty'"+// cWrapperName: "CasADi__isEmpty_TIC"+// protoArgs: "(CasADi::Matrix< double >* x0)"+// params: [ConstRef (NonVec (CasadiClass DMatrix))]+// args: "(x0_)"+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__isEmpty_TIC(CasADi::Matrix< double >* x0)"+// call: "CasADi::isEmpty(x0_)"+extern "C"+ bool* CasADi__isEmpty_TIC(CasADi::Matrix< double >* x0);+bool* CasADi__isEmpty_TIC(CasADi::Matrix< double >* x0){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);++ return new bool( CasADi::isEmpty(x0_) );+}+++// ================== function "CasADi::isInteger'" ===============+// cppName: "CasADi::isInteger'"+// cWrapperName: "CasADi__isInteger_TIC"+// protoArgs: "(CasADi::Matrix< double >* x0)"+// params: [ConstRef (NonVec (CasadiClass DMatrix))]+// args: "(x0_)"+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__isInteger_TIC(CasADi::Matrix< double >* x0)"+// call: "CasADi::isInteger(x0_)"+extern "C"+ bool* CasADi__isInteger_TIC(CasADi::Matrix< double >* x0);+bool* CasADi__isInteger_TIC(CasADi::Matrix< double >* x0){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);++ return new bool( CasADi::isInteger(x0_) );+}+++// ================== function "CasADi::isScalar'" ===============+// cppName: "CasADi::isScalar'"+// cWrapperName: "CasADi__isScalar_TIC"+// protoArgs: "(CasADi::Matrix< double >* x0)"+// params: [ConstRef (NonVec (CasadiClass DMatrix))]+// args: "(x0_)"+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__isScalar_TIC(CasADi::Matrix< double >* x0)"+// call: "CasADi::isScalar(x0_)"+extern "C"+ bool* CasADi__isScalar_TIC(CasADi::Matrix< double >* x0);+bool* CasADi__isScalar_TIC(CasADi::Matrix< double >* x0){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);++ return new bool( CasADi::isScalar(x0_) );+}+++// ================== function "CasADi::isVector'" ===============+// cppName: "CasADi::isVector'"+// cWrapperName: "CasADi__isVector_TIC"+// protoArgs: "(CasADi::Matrix< double >* x0)"+// params: [ConstRef (NonVec (CasadiClass DMatrix))]+// args: "(x0_)"+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__isVector_TIC(CasADi::Matrix< double >* x0)"+// call: "CasADi::isVector(x0_)"+extern "C"+ bool* CasADi__isVector_TIC(CasADi::Matrix< double >* x0);+bool* CasADi__isVector_TIC(CasADi::Matrix< double >* x0){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);++ return new bool( CasADi::isVector(x0_) );+}+++// ================== function "CasADi::isTril'" ===============+// cppName: "CasADi::isTril'"+// cWrapperName: "CasADi__isTril_TIC"+// protoArgs: "(CasADi::Matrix< double >* x0)"+// params: [ConstRef (NonVec (CasadiClass DMatrix))]+// args: "(x0_)"+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__isTril_TIC(CasADi::Matrix< double >* x0)"+// call: "CasADi::isTril(x0_)"+extern "C"+ bool* CasADi__isTril_TIC(CasADi::Matrix< double >* x0);+bool* CasADi__isTril_TIC(CasADi::Matrix< double >* x0){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);++ return new bool( CasADi::isTril(x0_) );+}+++// ================== function "CasADi::isTriu'" ===============+// cppName: "CasADi::isTriu'"+// cWrapperName: "CasADi__isTriu_TIC"+// protoArgs: "(CasADi::Matrix< double >* x0)"+// params: [ConstRef (NonVec (CasadiClass DMatrix))]+// args: "(x0_)"+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__isTriu_TIC(CasADi::Matrix< double >* x0)"+// call: "CasADi::isTriu(x0_)"+extern "C"+ bool* CasADi__isTriu_TIC(CasADi::Matrix< double >* x0);+bool* CasADi__isTriu_TIC(CasADi::Matrix< double >* x0){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);++ return new bool( CasADi::isTriu(x0_) );+}+++// ================== function "CasADi::det'" ===============+// cppName: "CasADi::det'"+// cWrapperName: "CasADi__det_TIC"+// protoArgs: "(CasADi::Matrix< double >* x0)"+// params: [ConstRef (NonVec (CasadiClass DMatrix))]+// args: "(x0_)"+// cWrapperRetType: "double"+// proto: "double CasADi__det_TIC(CasADi::Matrix< double >* x0)"+// call: "CasADi::det(x0_)"+extern "C"+ double CasADi__det_TIC(CasADi::Matrix< double >* x0);+double CasADi__det_TIC(CasADi::Matrix< double >* x0){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);++ return CasADi::det(x0_);+}+++// ================== function "CasADi::getMinor'" ===============+// cppName: "CasADi::getMinor'"+// cWrapperName: "CasADi__getMinor_TIC"+// protoArgs: "(CasADi::Matrix< double >* x0, int x1, int x2)"+// params: [ConstRef (NonVec (CasadiClass DMatrix)),Val (NonVec CInt),Val (NonVec CInt)]+// args: "(x0_, x1_, x2_)"+// cWrapperRetType: "double"+// proto: "double CasADi__getMinor_TIC(CasADi::Matrix< double >* x0, int x1, int x2)"+// call: "CasADi::getMinor(x0_, x1_, x2_)"+extern "C"+ double CasADi__getMinor_TIC(CasADi::Matrix< double >* x0, int x1, int x2);+double CasADi__getMinor_TIC(CasADi::Matrix< double >* x0, int x1, int x2){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);+ int x2_ = Marshaling<int,int>::marshal(x2);++ return CasADi::getMinor(x0_, x1_, x2_);+}+++// ================== function "CasADi::cofactor'" ===============+// cppName: "CasADi::cofactor'"+// cWrapperName: "CasADi__cofactor_TIC"+// protoArgs: "(CasADi::Matrix< double >* x0, int x1, int x2)"+// params: [ConstRef (NonVec (CasadiClass DMatrix)),Val (NonVec CInt),Val (NonVec CInt)]+// args: "(x0_, x1_, x2_)"+// cWrapperRetType: "double"+// proto: "double CasADi__cofactor_TIC(CasADi::Matrix< double >* x0, int x1, int x2)"+// call: "CasADi::cofactor(x0_, x1_, x2_)"+extern "C"+ double CasADi__cofactor_TIC(CasADi::Matrix< double >* x0, int x1, int x2);+double CasADi__cofactor_TIC(CasADi::Matrix< double >* x0, int x1, int x2){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);+ int x2_ = Marshaling<int,int>::marshal(x2);++ return CasADi::cofactor(x0_, x1_, x2_);+}+++// ================== function "CasADi::adj'" ===============+// cppName: "CasADi::adj'"+// cWrapperName: "CasADi__adj_TIC"+// protoArgs: "(CasADi::Matrix< double >* x0)"+// params: [ConstRef (NonVec (CasadiClass DMatrix))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__adj_TIC(CasADi::Matrix< double >* x0)"+// call: "CasADi::adj(x0_)"+extern "C"+ CasADi::Matrix< double >* CasADi__adj_TIC(CasADi::Matrix< double >* x0);+CasADi::Matrix< double >* CasADi__adj_TIC(CasADi::Matrix< double >* x0){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);++ return new CasADi::Matrix< double >( CasADi::adj(x0_) );+}+++// ================== function "CasADi::inv'" ===============+// cppName: "CasADi::inv'"+// cWrapperName: "CasADi__inv_TIC"+// protoArgs: "(CasADi::Matrix< double >* x0)"+// params: [ConstRef (NonVec (CasadiClass DMatrix))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__inv_TIC(CasADi::Matrix< double >* x0)"+// call: "CasADi::inv(x0_)"+extern "C"+ CasADi::Matrix< double >* CasADi__inv_TIC(CasADi::Matrix< double >* x0);+CasADi::Matrix< double >* CasADi__inv_TIC(CasADi::Matrix< double >* x0){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);++ return new CasADi::Matrix< double >( CasADi::inv(x0_) );+}+++// ================== function "CasADi::reshape''" ===============+// cppName: "CasADi::reshape''"+// cWrapperName: "CasADi__reshape_TIC_TIC"+// protoArgs: "(CasADi::Matrix< double >* x0, int x1, int x2)"+// params: [ConstRef (NonVec (CasadiClass DMatrix)),Val (NonVec CInt),Val (NonVec CInt)]+// args: "(x0_, x1_, x2_)"+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__reshape_TIC_TIC(CasADi::Matrix< double >* x0, int x1, int x2)"+// call: "CasADi::reshape(x0_, x1_, x2_)"+extern "C"+ CasADi::Matrix< double >* CasADi__reshape_TIC_TIC(CasADi::Matrix< double >* x0, int x1, int x2);+CasADi::Matrix< double >* CasADi__reshape_TIC_TIC(CasADi::Matrix< double >* x0, int x1, int x2){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);+ int x2_ = Marshaling<int,int>::marshal(x2);++ return new CasADi::Matrix< double >( CasADi::reshape(x0_, x1_, x2_) );+}+++// ================== function "CasADi::reshape'''" ===============+// cppName: "CasADi::reshape'''"+// cWrapperName: "CasADi__reshape_TIC_TIC_TIC"+// protoArgs: "(CasADi::Matrix< double >* x0, CasADi::CRSSparsity* x1)"+// params: [ConstRef (NonVec (CasadiClass DMatrix)),ConstRef (NonVec (CasadiClass CRSSparsity))]+// args: "(x0_, x1_)"+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__reshape_TIC_TIC_TIC(CasADi::Matrix< double >* x0, CasADi::CRSSparsity* x1)"+// call: "CasADi::reshape(x0_, x1_)"+extern "C"+ CasADi::Matrix< double >* CasADi__reshape_TIC_TIC_TIC(CasADi::Matrix< double >* x0, CasADi::CRSSparsity* x1);+CasADi::Matrix< double >* CasADi__reshape_TIC_TIC_TIC(CasADi::Matrix< double >* x0, CasADi::CRSSparsity* x1){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);+ CasADi::CRSSparsity x1_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x1);++ return new CasADi::Matrix< double >( CasADi::reshape(x0_, x1_) );+}+++// ================== function "CasADi::vec'" ===============+// cppName: "CasADi::vec'"+// cWrapperName: "CasADi__vec_TIC"+// protoArgs: "(CasADi::Matrix< double >* x0)"+// params: [ConstRef (NonVec (CasadiClass DMatrix))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__vec_TIC(CasADi::Matrix< double >* x0)"+// call: "CasADi::vec(x0_)"+extern "C"+ CasADi::Matrix< double >* CasADi__vec_TIC(CasADi::Matrix< double >* x0);+CasADi::Matrix< double >* CasADi__vec_TIC(CasADi::Matrix< double >* x0){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);++ return new CasADi::Matrix< double >( CasADi::vec(x0_) );+}+++// ================== function "CasADi::flatten'" ===============+// cppName: "CasADi::flatten'"+// cWrapperName: "CasADi__flatten_TIC"+// protoArgs: "(CasADi::Matrix< double >* x0)"+// params: [ConstRef (NonVec (CasadiClass DMatrix))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__flatten_TIC(CasADi::Matrix< double >* x0)"+// call: "CasADi::flatten(x0_)"+extern "C"+ CasADi::Matrix< double >* CasADi__flatten_TIC(CasADi::Matrix< double >* x0);+CasADi::Matrix< double >* CasADi__flatten_TIC(CasADi::Matrix< double >* x0){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);++ return new CasADi::Matrix< double >( CasADi::flatten(x0_) );+}+++// ================== function "CasADi::vecNZ'" ===============+// cppName: "CasADi::vecNZ'"+// cWrapperName: "CasADi__vecNZ_TIC"+// protoArgs: "(CasADi::Matrix< double >* x0)"+// params: [ConstRef (NonVec (CasadiClass DMatrix))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__vecNZ_TIC(CasADi::Matrix< double >* x0)"+// call: "CasADi::vecNZ(x0_)"+extern "C"+ CasADi::Matrix< double >* CasADi__vecNZ_TIC(CasADi::Matrix< double >* x0);+CasADi::Matrix< double >* CasADi__vecNZ_TIC(CasADi::Matrix< double >* x0){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);++ return new CasADi::Matrix< double >( CasADi::vecNZ(x0_) );+}+++// ================== function "CasADi::flattenNZ'" ===============+// cppName: "CasADi::flattenNZ'"+// cWrapperName: "CasADi__flattenNZ_TIC"+// protoArgs: "(CasADi::Matrix< double >* x0)"+// params: [ConstRef (NonVec (CasadiClass DMatrix))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__flattenNZ_TIC(CasADi::Matrix< double >* x0)"+// call: "CasADi::flattenNZ(x0_)"+extern "C"+ CasADi::Matrix< double >* CasADi__flattenNZ_TIC(CasADi::Matrix< double >* x0);+CasADi::Matrix< double >* CasADi__flattenNZ_TIC(CasADi::Matrix< double >* x0){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);++ return new CasADi::Matrix< double >( CasADi::flattenNZ(x0_) );+}+++// ================== function "CasADi::blockcat'" ===============+// cppName: "CasADi::blockcat'"+// cWrapperName: "CasADi__blockcat_TIC"+// protoArgs: "(std::vector<std::vector<CasADi::Matrix< double >* > > * x0)"+// params: [ConstRef (Vec (Vec (NonVec (CasadiClass DMatrix))))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__blockcat_TIC(std::vector<std::vector<CasADi::Matrix< double >* > > * x0)"+// call: "CasADi::blockcat(x0_)"+extern "C"+ CasADi::Matrix< double >* CasADi__blockcat_TIC(std::vector<std::vector<CasADi::Matrix< double >* > > * x0);+CasADi::Matrix< double >* CasADi__blockcat_TIC(std::vector<std::vector<CasADi::Matrix< double >* > > * x0){+ std::vector<std::vector<CasADi::Matrix< double > > > x0_ = Marshaling<std::vector<std::vector<CasADi::Matrix< double > > >,std::vector<std::vector<CasADi::Matrix< double >* > > *>::marshal(x0);++ return new CasADi::Matrix< double >( CasADi::blockcat(x0_) );+}+++// ================== function "CasADi::blocksplit''''" ===============+// cppName: "CasADi::blocksplit''''"+// cWrapperName: "CasADi__blocksplit_TIC_TIC_TIC_TIC"+// protoArgs: "(CasADi::Matrix< double >* x0, std::vector<int > * x1, std::vector<int > * x2)"+// params: [ConstRef (NonVec (CasadiClass DMatrix)),ConstRef (Vec (NonVec CInt)),ConstRef (Vec (NonVec CInt))]+// args: "(x0_, x1_, x2_)"+// cWrapperRetType: "std::vector<std::vector<CasADi::Matrix< double > > >*"+// proto: "std::vector<std::vector<CasADi::Matrix< double > > >* CasADi__blocksplit_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* x0, std::vector<int > * x1, std::vector<int > * x2)"+// call: "CasADi::blocksplit(x0_, x1_, x2_)"+extern "C"+ std::vector<std::vector<CasADi::Matrix< double > > >* CasADi__blocksplit_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* x0, std::vector<int > * x1, std::vector<int > * x2);+std::vector<std::vector<CasADi::Matrix< double > > >* CasADi__blocksplit_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* x0, std::vector<int > * x1, std::vector<int > * x2){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);+ std::vector<int > x1_ = Marshaling<std::vector<int >,std::vector<int > *>::marshal(x1);+ std::vector<int > x2_ = Marshaling<std::vector<int >,std::vector<int > *>::marshal(x2);++ return new std::vector<std::vector<CasADi::Matrix< double > > >( CasADi::blocksplit(x0_, x1_, x2_) );+}+++// ================== function "CasADi::blocksplit'''''" ===============+// cppName: "CasADi::blocksplit'''''"+// cWrapperName: "CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC"+// protoArgs: "(CasADi::Matrix< double >* x0, int x1, int x2)"+// params: [ConstRef (NonVec (CasadiClass DMatrix)),Val (NonVec CInt),Val (NonVec CInt)]+// args: "(x0_, x1_, x2_)"+// cWrapperRetType: "std::vector<std::vector<CasADi::Matrix< double > > >*"+// proto: "std::vector<std::vector<CasADi::Matrix< double > > >* CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* x0, int x1, int x2)"+// call: "CasADi::blocksplit(x0_, x1_, x2_)"+extern "C"+ std::vector<std::vector<CasADi::Matrix< double > > >* CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* x0, int x1, int x2);+std::vector<std::vector<CasADi::Matrix< double > > >* CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* x0, int x1, int x2){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);+ int x2_ = Marshaling<int,int>::marshal(x2);++ return new std::vector<std::vector<CasADi::Matrix< double > > >( CasADi::blocksplit(x0_, x1_, x2_) );+}+++// ================== function "CasADi::blocksplit''''''" ===============+// cppName: "CasADi::blocksplit''''''"+// cWrapperName: "CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC"+// protoArgs: "(CasADi::Matrix< double >* x0, int x1)"+// params: [ConstRef (NonVec (CasadiClass DMatrix)),Val (NonVec CInt)]+// args: "(x0_, x1_)"+// cWrapperRetType: "std::vector<std::vector<CasADi::Matrix< double > > >*"+// proto: "std::vector<std::vector<CasADi::Matrix< double > > >* CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* x0, int x1)"+// call: "CasADi::blocksplit(x0_, x1_)"+extern "C"+ std::vector<std::vector<CasADi::Matrix< double > > >* CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* x0, int x1);+std::vector<std::vector<CasADi::Matrix< double > > >* CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* x0, int x1){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);++ return new std::vector<std::vector<CasADi::Matrix< double > > >( CasADi::blocksplit(x0_, x1_) );+}+++// ================== function "CasADi::blocksplit'''''''" ===============+// cppName: "CasADi::blocksplit'''''''"+// cWrapperName: "CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC"+// protoArgs: "(CasADi::Matrix< double >* x0)"+// params: [ConstRef (NonVec (CasadiClass DMatrix))]+// args: "(x0_)"+// cWrapperRetType: "std::vector<std::vector<CasADi::Matrix< double > > >*"+// proto: "std::vector<std::vector<CasADi::Matrix< double > > >* CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* x0)"+// call: "CasADi::blocksplit(x0_)"+extern "C"+ std::vector<std::vector<CasADi::Matrix< double > > >* CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* x0);+std::vector<std::vector<CasADi::Matrix< double > > >* CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* x0){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);++ return new std::vector<std::vector<CasADi::Matrix< double > > >( CasADi::blocksplit(x0_) );+}+++// ================== function "CasADi::horzcat'" ===============+// cppName: "CasADi::horzcat'"+// cWrapperName: "CasADi__horzcat_TIC"+// protoArgs: "(std::vector<CasADi::Matrix< double >* > * x0)"+// params: [ConstRef (Vec (NonVec (CasadiClass DMatrix)))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__horzcat_TIC(std::vector<CasADi::Matrix< double >* > * x0)"+// call: "CasADi::horzcat(x0_)"+extern "C"+ CasADi::Matrix< double >* CasADi__horzcat_TIC(std::vector<CasADi::Matrix< double >* > * x0);+CasADi::Matrix< double >* CasADi__horzcat_TIC(std::vector<CasADi::Matrix< double >* > * x0){+ std::vector<CasADi::Matrix< double > > x0_ = Marshaling<std::vector<CasADi::Matrix< double > >,std::vector<CasADi::Matrix< double >* > *>::marshal(x0);++ return new CasADi::Matrix< double >( CasADi::horzcat(x0_) );+}+++// ================== function "CasADi::horzsplit'''" ===============+// cppName: "CasADi::horzsplit'''"+// cWrapperName: "CasADi__horzsplit_TIC_TIC_TIC"+// protoArgs: "(CasADi::Matrix< double >* x0, std::vector<int > * x1)"+// params: [ConstRef (NonVec (CasadiClass DMatrix)),ConstRef (Vec (NonVec CInt))]+// args: "(x0_, x1_)"+// cWrapperRetType: "std::vector<CasADi::Matrix< double > >*"+// proto: "std::vector<CasADi::Matrix< double > >* CasADi__horzsplit_TIC_TIC_TIC(CasADi::Matrix< double >* x0, std::vector<int > * x1)"+// call: "CasADi::horzsplit(x0_, x1_)"+extern "C"+ std::vector<CasADi::Matrix< double > >* CasADi__horzsplit_TIC_TIC_TIC(CasADi::Matrix< double >* x0, std::vector<int > * x1);+std::vector<CasADi::Matrix< double > >* CasADi__horzsplit_TIC_TIC_TIC(CasADi::Matrix< double >* x0, std::vector<int > * x1){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);+ std::vector<int > x1_ = Marshaling<std::vector<int >,std::vector<int > *>::marshal(x1);++ return new std::vector<CasADi::Matrix< double > >( CasADi::horzsplit(x0_, x1_) );+}+++// ================== function "CasADi::horzsplit''''" ===============+// cppName: "CasADi::horzsplit''''"+// cWrapperName: "CasADi__horzsplit_TIC_TIC_TIC_TIC"+// protoArgs: "(CasADi::Matrix< double >* x0, int x1)"+// params: [ConstRef (NonVec (CasadiClass DMatrix)),Val (NonVec CInt)]+// args: "(x0_, x1_)"+// cWrapperRetType: "std::vector<CasADi::Matrix< double > >*"+// proto: "std::vector<CasADi::Matrix< double > >* CasADi__horzsplit_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* x0, int x1)"+// call: "CasADi::horzsplit(x0_, x1_)"+extern "C"+ std::vector<CasADi::Matrix< double > >* CasADi__horzsplit_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* x0, int x1);+std::vector<CasADi::Matrix< double > >* CasADi__horzsplit_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* x0, int x1){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);++ return new std::vector<CasADi::Matrix< double > >( CasADi::horzsplit(x0_, x1_) );+}+++// ================== function "CasADi::horzsplit'''''" ===============+// cppName: "CasADi::horzsplit'''''"+// cWrapperName: "CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC"+// protoArgs: "(CasADi::Matrix< double >* x0)"+// params: [ConstRef (NonVec (CasadiClass DMatrix))]+// args: "(x0_)"+// cWrapperRetType: "std::vector<CasADi::Matrix< double > >*"+// proto: "std::vector<CasADi::Matrix< double > >* CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* x0)"+// call: "CasADi::horzsplit(x0_)"+extern "C"+ std::vector<CasADi::Matrix< double > >* CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* x0);+std::vector<CasADi::Matrix< double > >* CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* x0){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);++ return new std::vector<CasADi::Matrix< double > >( CasADi::horzsplit(x0_) );+}+++// ================== function "CasADi::vertcat'" ===============+// cppName: "CasADi::vertcat'"+// cWrapperName: "CasADi__vertcat_TIC"+// protoArgs: "(std::vector<CasADi::Matrix< double >* > * x0)"+// params: [ConstRef (Vec (NonVec (CasadiClass DMatrix)))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__vertcat_TIC(std::vector<CasADi::Matrix< double >* > * x0)"+// call: "CasADi::vertcat(x0_)"+extern "C"+ CasADi::Matrix< double >* CasADi__vertcat_TIC(std::vector<CasADi::Matrix< double >* > * x0);+CasADi::Matrix< double >* CasADi__vertcat_TIC(std::vector<CasADi::Matrix< double >* > * x0){+ std::vector<CasADi::Matrix< double > > x0_ = Marshaling<std::vector<CasADi::Matrix< double > >,std::vector<CasADi::Matrix< double >* > *>::marshal(x0);++ return new CasADi::Matrix< double >( CasADi::vertcat(x0_) );+}+++// ================== function "CasADi::vertsplit'''" ===============+// cppName: "CasADi::vertsplit'''"+// cWrapperName: "CasADi__vertsplit_TIC_TIC_TIC"+// protoArgs: "(CasADi::Matrix< double >* x0, std::vector<int > * x1)"+// params: [ConstRef (NonVec (CasadiClass DMatrix)),ConstRef (Vec (NonVec CInt))]+// args: "(x0_, x1_)"+// cWrapperRetType: "std::vector<CasADi::Matrix< double > >*"+// proto: "std::vector<CasADi::Matrix< double > >* CasADi__vertsplit_TIC_TIC_TIC(CasADi::Matrix< double >* x0, std::vector<int > * x1)"+// call: "CasADi::vertsplit(x0_, x1_)"+extern "C"+ std::vector<CasADi::Matrix< double > >* CasADi__vertsplit_TIC_TIC_TIC(CasADi::Matrix< double >* x0, std::vector<int > * x1);+std::vector<CasADi::Matrix< double > >* CasADi__vertsplit_TIC_TIC_TIC(CasADi::Matrix< double >* x0, std::vector<int > * x1){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);+ std::vector<int > x1_ = Marshaling<std::vector<int >,std::vector<int > *>::marshal(x1);++ return new std::vector<CasADi::Matrix< double > >( CasADi::vertsplit(x0_, x1_) );+}+++// ================== function "CasADi::vertsplit''''" ===============+// cppName: "CasADi::vertsplit''''"+// cWrapperName: "CasADi__vertsplit_TIC_TIC_TIC_TIC"+// protoArgs: "(CasADi::Matrix< double >* x0, int x1)"+// params: [ConstRef (NonVec (CasadiClass DMatrix)),Val (NonVec CInt)]+// args: "(x0_, x1_)"+// cWrapperRetType: "std::vector<CasADi::Matrix< double > >*"+// proto: "std::vector<CasADi::Matrix< double > >* CasADi__vertsplit_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* x0, int x1)"+// call: "CasADi::vertsplit(x0_, x1_)"+extern "C"+ std::vector<CasADi::Matrix< double > >* CasADi__vertsplit_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* x0, int x1);+std::vector<CasADi::Matrix< double > >* CasADi__vertsplit_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* x0, int x1){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);++ return new std::vector<CasADi::Matrix< double > >( CasADi::vertsplit(x0_, x1_) );+}+++// ================== function "CasADi::vertsplit'''''" ===============+// cppName: "CasADi::vertsplit'''''"+// cWrapperName: "CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC"+// protoArgs: "(CasADi::Matrix< double >* x0)"+// params: [ConstRef (NonVec (CasadiClass DMatrix))]+// args: "(x0_)"+// cWrapperRetType: "std::vector<CasADi::Matrix< double > >*"+// proto: "std::vector<CasADi::Matrix< double > >* CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* x0)"+// call: "CasADi::vertsplit(x0_)"+extern "C"+ std::vector<CasADi::Matrix< double > >* CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* x0);+std::vector<CasADi::Matrix< double > >* CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* x0){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);++ return new std::vector<CasADi::Matrix< double > >( CasADi::vertsplit(x0_) );+}+++// ================== function "CasADi::inner_prod'" ===============+// cppName: "CasADi::inner_prod'"+// cWrapperName: "CasADi__inner_prod_TIC"+// protoArgs: "(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1)"+// params: [ConstRef (NonVec (CasadiClass DMatrix)),ConstRef (NonVec (CasadiClass DMatrix))]+// args: "(x0_, x1_)"+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__inner_prod_TIC(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1)"+// call: "CasADi::inner_prod(x0_, x1_)"+extern "C"+ CasADi::Matrix< double >* CasADi__inner_prod_TIC(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1);+CasADi::Matrix< double >* CasADi__inner_prod_TIC(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);+ CasADi::Matrix< double > x1_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x1);++ return new CasADi::Matrix< double >( CasADi::inner_prod(x0_, x1_) );+}+++// ================== function "CasADi::outer_prod'" ===============+// cppName: "CasADi::outer_prod'"+// cWrapperName: "CasADi__outer_prod_TIC"+// protoArgs: "(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1)"+// params: [ConstRef (NonVec (CasadiClass DMatrix)),ConstRef (NonVec (CasadiClass DMatrix))]+// args: "(x0_, x1_)"+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__outer_prod_TIC(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1)"+// call: "CasADi::outer_prod(x0_, x1_)"+extern "C"+ CasADi::Matrix< double >* CasADi__outer_prod_TIC(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1);+CasADi::Matrix< double >* CasADi__outer_prod_TIC(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);+ CasADi::Matrix< double > x1_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x1);++ return new CasADi::Matrix< double >( CasADi::outer_prod(x0_, x1_) );+}+++// ================== function "CasADi::norm_1'" ===============+// cppName: "CasADi::norm_1'"+// cWrapperName: "CasADi__norm_1_TIC"+// protoArgs: "(CasADi::Matrix< double >* x0)"+// params: [ConstRef (NonVec (CasadiClass DMatrix))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__norm_1_TIC(CasADi::Matrix< double >* x0)"+// call: "CasADi::norm_1(x0_)"+extern "C"+ CasADi::Matrix< double >* CasADi__norm_1_TIC(CasADi::Matrix< double >* x0);+CasADi::Matrix< double >* CasADi__norm_1_TIC(CasADi::Matrix< double >* x0){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);++ return new CasADi::Matrix< double >( CasADi::norm_1(x0_) );+}+++// ================== function "CasADi::norm_2'" ===============+// cppName: "CasADi::norm_2'"+// cWrapperName: "CasADi__norm_2_TIC"+// protoArgs: "(CasADi::Matrix< double >* x0)"+// params: [ConstRef (NonVec (CasadiClass DMatrix))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__norm_2_TIC(CasADi::Matrix< double >* x0)"+// call: "CasADi::norm_2(x0_)"+extern "C"+ CasADi::Matrix< double >* CasADi__norm_2_TIC(CasADi::Matrix< double >* x0);+CasADi::Matrix< double >* CasADi__norm_2_TIC(CasADi::Matrix< double >* x0){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);++ return new CasADi::Matrix< double >( CasADi::norm_2(x0_) );+}+++// ================== function "CasADi::norm_inf'" ===============+// cppName: "CasADi::norm_inf'"+// cWrapperName: "CasADi__norm_inf_TIC"+// protoArgs: "(CasADi::Matrix< double >* x0)"+// params: [ConstRef (NonVec (CasadiClass DMatrix))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__norm_inf_TIC(CasADi::Matrix< double >* x0)"+// call: "CasADi::norm_inf(x0_)"+extern "C"+ CasADi::Matrix< double >* CasADi__norm_inf_TIC(CasADi::Matrix< double >* x0);+CasADi::Matrix< double >* CasADi__norm_inf_TIC(CasADi::Matrix< double >* x0){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);++ return new CasADi::Matrix< double >( CasADi::norm_inf(x0_) );+}+++// ================== function "CasADi::norm_F'" ===============+// cppName: "CasADi::norm_F'"+// cWrapperName: "CasADi__norm_F_TIC"+// protoArgs: "(CasADi::Matrix< double >* x0)"+// params: [ConstRef (NonVec (CasadiClass DMatrix))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__norm_F_TIC(CasADi::Matrix< double >* x0)"+// call: "CasADi::norm_F(x0_)"+extern "C"+ CasADi::Matrix< double >* CasADi__norm_F_TIC(CasADi::Matrix< double >* x0);+CasADi::Matrix< double >* CasADi__norm_F_TIC(CasADi::Matrix< double >* x0){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);++ return new CasADi::Matrix< double >( CasADi::norm_F(x0_) );+}+++// ================== function "CasADi::qr'" ===============+// cppName: "CasADi::qr'"+// cWrapperName: "CasADi__qr_TIC"+// protoArgs: "(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1, CasADi::Matrix< double >* x2)"+// params: [ConstRef (NonVec (CasadiClass DMatrix)),Ref (NonVec (CasadiClass DMatrix)),Ref (NonVec (CasadiClass DMatrix))]+// args: "(x0_, x1_, x2_)"+// cWrapperRetType: "void"+// proto: "void CasADi__qr_TIC(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1, CasADi::Matrix< double >* x2)"+// call: "CasADi::qr(x0_, x1_, x2_)"+extern "C"+ void CasADi__qr_TIC(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1, CasADi::Matrix< double >* x2);+void CasADi__qr_TIC(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1, CasADi::Matrix< double >* x2){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);+ CasADi::Matrix< double > x1_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x1);+ CasADi::Matrix< double > x2_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x2);++ return CasADi::qr(x0_, x1_, x2_);+}+++// ================== function "CasADi::nullspace'" ===============+// cppName: "CasADi::nullspace'"+// cWrapperName: "CasADi__nullspace_TIC"+// protoArgs: "(CasADi::Matrix< double >* x0)"+// params: [ConstRef (NonVec (CasadiClass DMatrix))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__nullspace_TIC(CasADi::Matrix< double >* x0)"+// call: "CasADi::nullspace(x0_)"+extern "C"+ CasADi::Matrix< double >* CasADi__nullspace_TIC(CasADi::Matrix< double >* x0);+CasADi::Matrix< double >* CasADi__nullspace_TIC(CasADi::Matrix< double >* x0){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);++ return new CasADi::Matrix< double >( CasADi::nullspace(x0_) );+}+++// ================== function "CasADi::solve'" ===============+// cppName: "CasADi::solve'"+// cWrapperName: "CasADi__solve_TIC"+// protoArgs: "(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1)"+// params: [ConstRef (NonVec (CasadiClass DMatrix)),ConstRef (NonVec (CasadiClass DMatrix))]+// args: "(x0_, x1_)"+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__solve_TIC(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1)"+// call: "CasADi::solve(x0_, x1_)"+extern "C"+ CasADi::Matrix< double >* CasADi__solve_TIC(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1);+CasADi::Matrix< double >* CasADi__solve_TIC(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);+ CasADi::Matrix< double > x1_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x1);++ return new CasADi::Matrix< double >( CasADi::solve(x0_, x1_) );+}+++// ================== function "CasADi::pinv'" ===============+// cppName: "CasADi::pinv'"+// cWrapperName: "CasADi__pinv_TIC"+// protoArgs: "(CasADi::Matrix< double >* x0)"+// params: [ConstRef (NonVec (CasadiClass DMatrix))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__pinv_TIC(CasADi::Matrix< double >* x0)"+// call: "CasADi::pinv(x0_)"+extern "C"+ CasADi::Matrix< double >* CasADi__pinv_TIC(CasADi::Matrix< double >* x0);+CasADi::Matrix< double >* CasADi__pinv_TIC(CasADi::Matrix< double >* x0){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);++ return new CasADi::Matrix< double >( CasADi::pinv(x0_) );+}+++// ================== function "CasADi::isZero'" ===============+// cppName: "CasADi::isZero'"+// cWrapperName: "CasADi__isZero_TIC"+// protoArgs: "(CasADi::Matrix< double >* x0)"+// params: [ConstRef (NonVec (CasadiClass DMatrix))]+// args: "(x0_)"+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__isZero_TIC(CasADi::Matrix< double >* x0)"+// call: "CasADi::isZero(x0_)"+extern "C"+ bool* CasADi__isZero_TIC(CasADi::Matrix< double >* x0);+bool* CasADi__isZero_TIC(CasADi::Matrix< double >* x0){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);++ return new bool( CasADi::isZero(x0_) );+}+++// ================== function "CasADi::isOne'" ===============+// cppName: "CasADi::isOne'"+// cWrapperName: "CasADi__isOne_TIC"+// protoArgs: "(CasADi::Matrix< double >* x0)"+// params: [ConstRef (NonVec (CasadiClass DMatrix))]+// args: "(x0_)"+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__isOne_TIC(CasADi::Matrix< double >* x0)"+// call: "CasADi::isOne(x0_)"+extern "C"+ bool* CasADi__isOne_TIC(CasADi::Matrix< double >* x0);+bool* CasADi__isOne_TIC(CasADi::Matrix< double >* x0){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);++ return new bool( CasADi::isOne(x0_) );+}+++// ================== function "CasADi::isMinusOne'" ===============+// cppName: "CasADi::isMinusOne'"+// cWrapperName: "CasADi__isMinusOne_TIC"+// protoArgs: "(CasADi::Matrix< double >* x0)"+// params: [ConstRef (NonVec (CasadiClass DMatrix))]+// args: "(x0_)"+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__isMinusOne_TIC(CasADi::Matrix< double >* x0)"+// call: "CasADi::isMinusOne(x0_)"+extern "C"+ bool* CasADi__isMinusOne_TIC(CasADi::Matrix< double >* x0);+bool* CasADi__isMinusOne_TIC(CasADi::Matrix< double >* x0){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);++ return new bool( CasADi::isMinusOne(x0_) );+}+++// ================== function "CasADi::isIdentity'" ===============+// cppName: "CasADi::isIdentity'"+// cWrapperName: "CasADi__isIdentity_TIC"+// protoArgs: "(CasADi::Matrix< double >* x0)"+// params: [ConstRef (NonVec (CasadiClass DMatrix))]+// args: "(x0_)"+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__isIdentity_TIC(CasADi::Matrix< double >* x0)"+// call: "CasADi::isIdentity(x0_)"+extern "C"+ bool* CasADi__isIdentity_TIC(CasADi::Matrix< double >* x0);+bool* CasADi__isIdentity_TIC(CasADi::Matrix< double >* x0){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);++ return new bool( CasADi::isIdentity(x0_) );+}+++// ================== function "CasADi::nnz'" ===============+// cppName: "CasADi::nnz'"+// cWrapperName: "CasADi__nnz_TIC"+// protoArgs: "(CasADi::Matrix< double >* x0)"+// params: [ConstRef (NonVec (CasadiClass DMatrix))]+// args: "(x0_)"+// cWrapperRetType: "int"+// proto: "int CasADi__nnz_TIC(CasADi::Matrix< double >* x0)"+// call: "CasADi::nnz(x0_)"+extern "C"+ int CasADi__nnz_TIC(CasADi::Matrix< double >* x0);+int CasADi__nnz_TIC(CasADi::Matrix< double >* x0){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);++ return CasADi::nnz(x0_);+}+++// ================== function "CasADi::nnz_sym'" ===============+// cppName: "CasADi::nnz_sym'"+// cWrapperName: "CasADi__nnz_sym_TIC"+// protoArgs: "(CasADi::Matrix< double >* x0)"+// params: [ConstRef (NonVec (CasadiClass DMatrix))]+// args: "(x0_)"+// cWrapperRetType: "int"+// proto: "int CasADi__nnz_sym_TIC(CasADi::Matrix< double >* x0)"+// call: "CasADi::nnz_sym(x0_)"+extern "C"+ int CasADi__nnz_sym_TIC(CasADi::Matrix< double >* x0);+int CasADi__nnz_sym_TIC(CasADi::Matrix< double >* x0){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);++ return CasADi::nnz_sym(x0_);+}+++// ================== function "CasADi::isEqual'" ===============+// cppName: "CasADi::isEqual'"+// cWrapperName: "CasADi__isEqual_TIC"+// protoArgs: "(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1)"+// params: [ConstRef (NonVec (CasadiClass DMatrix)),ConstRef (NonVec (CasadiClass DMatrix))]+// args: "(x0_, x1_)"+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__isEqual_TIC(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1)"+// call: "CasADi::isEqual(x0_, x1_)"+extern "C"+ bool* CasADi__isEqual_TIC(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1);+bool* CasADi__isEqual_TIC(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);+ CasADi::Matrix< double > x1_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x1);++ return new bool( CasADi::isEqual(x0_, x1_) );+}+++// ================== function "CasADi::repmat'" ===============+// cppName: "CasADi::repmat'"+// cWrapperName: "CasADi__repmat_TIC"+// protoArgs: "(CasADi::Matrix< double >* x0, int x1, int x2)"+// params: [ConstRef (NonVec (CasadiClass DMatrix)),Val (NonVec CInt),Val (NonVec CInt)]+// args: "(x0_, x1_, x2_)"+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__repmat_TIC(CasADi::Matrix< double >* x0, int x1, int x2)"+// call: "CasADi::repmat(x0_, x1_, x2_)"+extern "C"+ CasADi::Matrix< double >* CasADi__repmat_TIC(CasADi::Matrix< double >* x0, int x1, int x2);+CasADi::Matrix< double >* CasADi__repmat_TIC(CasADi::Matrix< double >* x0, int x1, int x2){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);+ int x2_ = Marshaling<int,int>::marshal(x2);++ return new CasADi::Matrix< double >( CasADi::repmat(x0_, x1_, x2_) );+}+++// ================== function "CasADi::getSparseTriplet'" ===============+// cppName: "CasADi::getSparseTriplet'"+// cWrapperName: "CasADi__getSparseTriplet_TIC"+// protoArgs: "(CasADi::Matrix< double >* x0)"+// params: [ConstRef (NonVec (CasadiClass DMatrix))]+// args: "(x0_)"+// cWrapperRetType: "std::vector<std::vector<int > >*"+// proto: "std::vector<std::vector<int > >* CasADi__getSparseTriplet_TIC(CasADi::Matrix< double >* x0)"+// call: "CasADi::getSparseTriplet(x0_)"+extern "C"+ std::vector<std::vector<int > >* CasADi__getSparseTriplet_TIC(CasADi::Matrix< double >* x0);+std::vector<std::vector<int > >* CasADi__getSparseTriplet_TIC(CasADi::Matrix< double >* x0){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);++ return new std::vector<std::vector<int > >( CasADi::getSparseTriplet(x0_) );+}+++// ================== function "CasADi::unite'" ===============+// cppName: "CasADi::unite'"+// cWrapperName: "CasADi__unite_TIC"+// protoArgs: "(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1)"+// params: [ConstRef (NonVec (CasadiClass DMatrix)),ConstRef (NonVec (CasadiClass DMatrix))]+// args: "(x0_, x1_)"+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__unite_TIC(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1)"+// call: "CasADi::unite(x0_, x1_)"+extern "C"+ CasADi::Matrix< double >* CasADi__unite_TIC(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1);+CasADi::Matrix< double >* CasADi__unite_TIC(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);+ CasADi::Matrix< double > x1_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x1);++ return new CasADi::Matrix< double >( CasADi::unite(x0_, x1_) );+}+++// ================== function "CasADi::sumCols'" ===============+// cppName: "CasADi::sumCols'"+// cWrapperName: "CasADi__sumCols_TIC"+// protoArgs: "(CasADi::Matrix< double >* x0)"+// params: [ConstRef (NonVec (CasadiClass DMatrix))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__sumCols_TIC(CasADi::Matrix< double >* x0)"+// call: "CasADi::sumCols(x0_)"+extern "C"+ CasADi::Matrix< double >* CasADi__sumCols_TIC(CasADi::Matrix< double >* x0);+CasADi::Matrix< double >* CasADi__sumCols_TIC(CasADi::Matrix< double >* x0){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);++ return new CasADi::Matrix< double >( CasADi::sumCols(x0_) );+}+++// ================== function "CasADi::sumRows'" ===============+// cppName: "CasADi::sumRows'"+// cWrapperName: "CasADi__sumRows_TIC"+// protoArgs: "(CasADi::Matrix< double >* x0)"+// params: [ConstRef (NonVec (CasadiClass DMatrix))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__sumRows_TIC(CasADi::Matrix< double >* x0)"+// call: "CasADi::sumRows(x0_)"+extern "C"+ CasADi::Matrix< double >* CasADi__sumRows_TIC(CasADi::Matrix< double >* x0);+CasADi::Matrix< double >* CasADi__sumRows_TIC(CasADi::Matrix< double >* x0){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);++ return new CasADi::Matrix< double >( CasADi::sumRows(x0_) );+}+++// ================== function "CasADi::sumAll'" ===============+// cppName: "CasADi::sumAll'"+// cWrapperName: "CasADi__sumAll_TIC"+// protoArgs: "(CasADi::Matrix< double >* x0)"+// params: [ConstRef (NonVec (CasadiClass DMatrix))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__sumAll_TIC(CasADi::Matrix< double >* x0)"+// call: "CasADi::sumAll(x0_)"+extern "C"+ CasADi::Matrix< double >* CasADi__sumAll_TIC(CasADi::Matrix< double >* x0);+CasADi::Matrix< double >* CasADi__sumAll_TIC(CasADi::Matrix< double >* x0){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);++ return new CasADi::Matrix< double >( CasADi::sumAll(x0_) );+}+++// ================== function "CasADi::trace'" ===============+// cppName: "CasADi::trace'"+// cWrapperName: "CasADi__trace_TIC"+// protoArgs: "(CasADi::Matrix< double >* x0)"+// params: [ConstRef (NonVec (CasadiClass DMatrix))]+// args: "(x0_)"+// cWrapperRetType: "double"+// proto: "double CasADi__trace_TIC(CasADi::Matrix< double >* x0)"+// call: "CasADi::trace(x0_)"+extern "C"+ double CasADi__trace_TIC(CasADi::Matrix< double >* x0);+double CasADi__trace_TIC(CasADi::Matrix< double >* x0){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);++ return CasADi::trace(x0_);+}+++// ================== function "CasADi::makeDense'" ===============+// cppName: "CasADi::makeDense'"+// cWrapperName: "CasADi__makeDense_TIC"+// protoArgs: "(CasADi::Matrix< double >* x0)"+// params: [Ref (NonVec (CasadiClass DMatrix))]+// args: "(x0_)"+// cWrapperRetType: "void"+// proto: "void CasADi__makeDense_TIC(CasADi::Matrix< double >* x0)"+// call: "CasADi::makeDense(x0_)"+extern "C"+ void CasADi__makeDense_TIC(CasADi::Matrix< double >* x0);+void CasADi__makeDense_TIC(CasADi::Matrix< double >* x0){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);++ return CasADi::makeDense(x0_);+}+++// ================== function "CasADi::densify'" ===============+// cppName: "CasADi::densify'"+// cWrapperName: "CasADi__densify_TIC"+// protoArgs: "(CasADi::Matrix< double >* x0)"+// params: [ConstRef (NonVec (CasadiClass DMatrix))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__densify_TIC(CasADi::Matrix< double >* x0)"+// call: "CasADi::densify(x0_)"+extern "C"+ CasADi::Matrix< double >* CasADi__densify_TIC(CasADi::Matrix< double >* x0);+CasADi::Matrix< double >* CasADi__densify_TIC(CasADi::Matrix< double >* x0){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);++ return new CasADi::Matrix< double >( CasADi::densify(x0_) );+}+++// ================== function "CasADi::makeSparse''" ===============+// cppName: "CasADi::makeSparse''"+// cWrapperName: "CasADi__makeSparse_TIC_TIC"+// protoArgs: "(CasADi::Matrix< double >* x0, double x1)"+// params: [Ref (NonVec (CasadiClass DMatrix)),Val (NonVec CDouble)]+// args: "(x0_, x1_)"+// cWrapperRetType: "void"+// proto: "void CasADi__makeSparse_TIC_TIC(CasADi::Matrix< double >* x0, double x1)"+// call: "CasADi::makeSparse(x0_, x1_)"+extern "C"+ void CasADi__makeSparse_TIC_TIC(CasADi::Matrix< double >* x0, double x1);+void CasADi__makeSparse_TIC_TIC(CasADi::Matrix< double >* x0, double x1){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);+ double x1_ = Marshaling<double,double>::marshal(x1);++ return CasADi::makeSparse(x0_, x1_);+}+++// ================== function "CasADi::makeSparse'''" ===============+// cppName: "CasADi::makeSparse'''"+// cWrapperName: "CasADi__makeSparse_TIC_TIC_TIC"+// protoArgs: "(CasADi::Matrix< double >* x0)"+// params: [Ref (NonVec (CasadiClass DMatrix))]+// args: "(x0_)"+// cWrapperRetType: "void"+// proto: "void CasADi__makeSparse_TIC_TIC_TIC(CasADi::Matrix< double >* x0)"+// call: "CasADi::makeSparse(x0_)"+extern "C"+ void CasADi__makeSparse_TIC_TIC_TIC(CasADi::Matrix< double >* x0);+void CasADi__makeSparse_TIC_TIC_TIC(CasADi::Matrix< double >* x0){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);++ return CasADi::makeSparse(x0_);+}+++// ================== function "CasADi::hasNonStructuralZeros'" ===============+// cppName: "CasADi::hasNonStructuralZeros'"+// cWrapperName: "CasADi__hasNonStructuralZeros_TIC"+// protoArgs: "(CasADi::Matrix< double >* x0)"+// params: [ConstRef (NonVec (CasadiClass DMatrix))]+// args: "(x0_)"+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__hasNonStructuralZeros_TIC(CasADi::Matrix< double >* x0)"+// call: "CasADi::hasNonStructuralZeros(x0_)"+extern "C"+ bool* CasADi__hasNonStructuralZeros_TIC(CasADi::Matrix< double >* x0);+bool* CasADi__hasNonStructuralZeros_TIC(CasADi::Matrix< double >* x0){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);++ return new bool( CasADi::hasNonStructuralZeros(x0_) );+}+++// ================== function "CasADi::diag'" ===============+// cppName: "CasADi::diag'"+// cWrapperName: "CasADi__diag_TIC"+// protoArgs: "(CasADi::Matrix< double >* x0)"+// params: [ConstRef (NonVec (CasadiClass DMatrix))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__diag_TIC(CasADi::Matrix< double >* x0)"+// call: "CasADi::diag(x0_)"+extern "C"+ CasADi::Matrix< double >* CasADi__diag_TIC(CasADi::Matrix< double >* x0);+CasADi::Matrix< double >* CasADi__diag_TIC(CasADi::Matrix< double >* x0){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);++ return new CasADi::Matrix< double >( CasADi::diag(x0_) );+}+++// ================== function "CasADi::blkdiag'" ===============+// cppName: "CasADi::blkdiag'"+// cWrapperName: "CasADi__blkdiag_TIC"+// protoArgs: "(std::vector<CasADi::Matrix< double >* > * x0)"+// params: [ConstRef (Vec (NonVec (CasadiClass DMatrix)))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__blkdiag_TIC(std::vector<CasADi::Matrix< double >* > * x0)"+// call: "CasADi::blkdiag(x0_)"+extern "C"+ CasADi::Matrix< double >* CasADi__blkdiag_TIC(std::vector<CasADi::Matrix< double >* > * x0);+CasADi::Matrix< double >* CasADi__blkdiag_TIC(std::vector<CasADi::Matrix< double >* > * x0){+ std::vector<CasADi::Matrix< double > > x0_ = Marshaling<std::vector<CasADi::Matrix< double > >,std::vector<CasADi::Matrix< double >* > *>::marshal(x0);++ return new CasADi::Matrix< double >( CasADi::blkdiag(x0_) );+}+++// ================== function "CasADi::polyval'" ===============+// cppName: "CasADi::polyval'"+// cWrapperName: "CasADi__polyval_TIC"+// protoArgs: "(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1)"+// params: [ConstRef (NonVec (CasadiClass DMatrix)),ConstRef (NonVec (CasadiClass DMatrix))]+// args: "(x0_, x1_)"+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__polyval_TIC(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1)"+// call: "CasADi::polyval(x0_, x1_)"+extern "C"+ CasADi::Matrix< double >* CasADi__polyval_TIC(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1);+CasADi::Matrix< double >* CasADi__polyval_TIC(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);+ CasADi::Matrix< double > x1_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x1);++ return new CasADi::Matrix< double >( CasADi::polyval(x0_, x1_) );+}+++// ================== function "CasADi::addMultiple''" ===============+// cppName: "CasADi::addMultiple''"+// cWrapperName: "CasADi__addMultiple_TIC_TIC"+// protoArgs: "(CasADi::Matrix< double >* x0, std::vector<double > * x1, std::vector<double >* x2, bool* x3)"+// params: [ConstRef (NonVec (CasadiClass DMatrix)),ConstRef (Vec (NonVec CDouble)),Ref (Vec (NonVec CDouble)),Val (NonVec CBool)]+// args: "(x0_, x1_, x2_, x3_)"+// cWrapperRetType: "void"+// proto: "void CasADi__addMultiple_TIC_TIC(CasADi::Matrix< double >* x0, std::vector<double > * x1, std::vector<double >* x2, bool* x3)"+// call: "CasADi::addMultiple(x0_, x1_, x2_, x3_)"+extern "C"+ void CasADi__addMultiple_TIC_TIC(CasADi::Matrix< double >* x0, std::vector<double > * x1, std::vector<double >* x2, bool* x3);+void CasADi__addMultiple_TIC_TIC(CasADi::Matrix< double >* x0, std::vector<double > * x1, std::vector<double >* x2, bool* x3){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);+ std::vector<double > x1_ = Marshaling<std::vector<double >,std::vector<double > *>::marshal(x1);+ std::vector<double > x2_ = Marshaling<std::vector<double >,std::vector<double >*>::marshal(x2);+ bool x3_ = Marshaling<bool,bool*>::marshal(x3);++ return CasADi::addMultiple(x0_, x1_, x2_, x3_);+}+++// ================== function "CasADi::addMultiple'''" ===============+// cppName: "CasADi::addMultiple'''"+// cWrapperName: "CasADi__addMultiple_TIC_TIC_TIC"+// protoArgs: "(CasADi::Matrix< double >* x0, std::vector<double > * x1, std::vector<double >* x2)"+// params: [ConstRef (NonVec (CasadiClass DMatrix)),ConstRef (Vec (NonVec CDouble)),Ref (Vec (NonVec CDouble))]+// args: "(x0_, x1_, x2_)"+// cWrapperRetType: "void"+// proto: "void CasADi__addMultiple_TIC_TIC_TIC(CasADi::Matrix< double >* x0, std::vector<double > * x1, std::vector<double >* x2)"+// call: "CasADi::addMultiple(x0_, x1_, x2_)"+extern "C"+ void CasADi__addMultiple_TIC_TIC_TIC(CasADi::Matrix< double >* x0, std::vector<double > * x1, std::vector<double >* x2);+void CasADi__addMultiple_TIC_TIC_TIC(CasADi::Matrix< double >* x0, std::vector<double > * x1, std::vector<double >* x2){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);+ std::vector<double > x1_ = Marshaling<std::vector<double >,std::vector<double > *>::marshal(x1);+ std::vector<double > x2_ = Marshaling<std::vector<double >,std::vector<double >*>::marshal(x2);++ return CasADi::addMultiple(x0_, x1_, x2_);+}+++// ================== function "CasADi::veccat'" ===============+// cppName: "CasADi::veccat'"+// cWrapperName: "CasADi__veccat_TIC"+// protoArgs: "(std::vector<CasADi::Matrix< double >* > * x0)"+// params: [ConstRef (Vec (NonVec (CasadiClass DMatrix)))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__veccat_TIC(std::vector<CasADi::Matrix< double >* > * x0)"+// call: "CasADi::veccat(x0_)"+extern "C"+ CasADi::Matrix< double >* CasADi__veccat_TIC(std::vector<CasADi::Matrix< double >* > * x0);+CasADi::Matrix< double >* CasADi__veccat_TIC(std::vector<CasADi::Matrix< double >* > * x0){+ std::vector<CasADi::Matrix< double > > x0_ = Marshaling<std::vector<CasADi::Matrix< double > >,std::vector<CasADi::Matrix< double >* > *>::marshal(x0);++ return new CasADi::Matrix< double >( CasADi::veccat(x0_) );+}+++// ================== function "CasADi::vecNZcat'" ===============+// cppName: "CasADi::vecNZcat'"+// cWrapperName: "CasADi__vecNZcat_TIC"+// protoArgs: "(std::vector<CasADi::Matrix< double >* > * x0)"+// params: [ConstRef (Vec (NonVec (CasadiClass DMatrix)))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__vecNZcat_TIC(std::vector<CasADi::Matrix< double >* > * x0)"+// call: "CasADi::vecNZcat(x0_)"+extern "C"+ CasADi::Matrix< double >* CasADi__vecNZcat_TIC(std::vector<CasADi::Matrix< double >* > * x0);+CasADi::Matrix< double >* CasADi__vecNZcat_TIC(std::vector<CasADi::Matrix< double >* > * x0){+ std::vector<CasADi::Matrix< double > > x0_ = Marshaling<std::vector<CasADi::Matrix< double > >,std::vector<CasADi::Matrix< double >* > *>::marshal(x0);++ return new CasADi::Matrix< double >( CasADi::vecNZcat(x0_) );+}+++// ================== function "CasADi::flattencat'" ===============+// cppName: "CasADi::flattencat'"+// cWrapperName: "CasADi__flattencat_TIC"+// protoArgs: "(std::vector<CasADi::Matrix< double >* > * x0)"+// params: [ConstRef (Vec (NonVec (CasadiClass DMatrix)))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__flattencat_TIC(std::vector<CasADi::Matrix< double >* > * x0)"+// call: "CasADi::flattencat(x0_)"+extern "C"+ CasADi::Matrix< double >* CasADi__flattencat_TIC(std::vector<CasADi::Matrix< double >* > * x0);+CasADi::Matrix< double >* CasADi__flattencat_TIC(std::vector<CasADi::Matrix< double >* > * x0){+ std::vector<CasADi::Matrix< double > > x0_ = Marshaling<std::vector<CasADi::Matrix< double > >,std::vector<CasADi::Matrix< double >* > *>::marshal(x0);++ return new CasADi::Matrix< double >( CasADi::flattencat(x0_) );+}+++// ================== function "CasADi::flattenNZcat'" ===============+// cppName: "CasADi::flattenNZcat'"+// cWrapperName: "CasADi__flattenNZcat_TIC"+// protoArgs: "(std::vector<CasADi::Matrix< double >* > * x0)"+// params: [ConstRef (Vec (NonVec (CasadiClass DMatrix)))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__flattenNZcat_TIC(std::vector<CasADi::Matrix< double >* > * x0)"+// call: "CasADi::flattenNZcat(x0_)"+extern "C"+ CasADi::Matrix< double >* CasADi__flattenNZcat_TIC(std::vector<CasADi::Matrix< double >* > * x0);+CasADi::Matrix< double >* CasADi__flattenNZcat_TIC(std::vector<CasADi::Matrix< double >* > * x0){+ std::vector<CasADi::Matrix< double > > x0_ = Marshaling<std::vector<CasADi::Matrix< double > >,std::vector<CasADi::Matrix< double >* > *>::marshal(x0);++ return new CasADi::Matrix< double >( CasADi::flattenNZcat(x0_) );+}+++// ================== function "CasADi::project'" ===============+// cppName: "CasADi::project'"+// cWrapperName: "CasADi__project_TIC"+// protoArgs: "(CasADi::Matrix< double >* x0, CasADi::CRSSparsity* x1)"+// params: [ConstRef (NonVec (CasadiClass DMatrix)),ConstRef (NonVec (CasadiClass CRSSparsity))]+// args: "(x0_, x1_)"+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__project_TIC(CasADi::Matrix< double >* x0, CasADi::CRSSparsity* x1)"+// call: "CasADi::project(x0_, x1_)"+extern "C"+ CasADi::Matrix< double >* CasADi__project_TIC(CasADi::Matrix< double >* x0, CasADi::CRSSparsity* x1);+CasADi::Matrix< double >* CasADi__project_TIC(CasADi::Matrix< double >* x0, CasADi::CRSSparsity* x1){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);+ CasADi::CRSSparsity x1_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x1);++ return new CasADi::Matrix< double >( CasADi::project(x0_, x1_) );+}+++// ================== function "CasADi::sprank'" ===============+// cppName: "CasADi::sprank'"+// cWrapperName: "CasADi__sprank_TIC"+// protoArgs: "(CasADi::Matrix< double >* x0)"+// params: [ConstRef (NonVec (CasadiClass DMatrix))]+// args: "(x0_)"+// cWrapperRetType: "int"+// proto: "int CasADi__sprank_TIC(CasADi::Matrix< double >* x0)"+// call: "CasADi::sprank(x0_)"+extern "C"+ int CasADi__sprank_TIC(CasADi::Matrix< double >* x0);+int CasADi__sprank_TIC(CasADi::Matrix< double >* x0){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);++ return CasADi::sprank(x0_);+}+++// ================== function "CasADi::kron'" ===============+// cppName: "CasADi::kron'"+// cWrapperName: "CasADi__kron_TIC"+// protoArgs: "(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1)"+// params: [ConstRef (NonVec (CasadiClass DMatrix)),ConstRef (NonVec (CasadiClass DMatrix))]+// args: "(x0_, x1_)"+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__kron_TIC(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1)"+// call: "CasADi::kron(x0_, x1_)"+extern "C"+ CasADi::Matrix< double >* CasADi__kron_TIC(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1);+CasADi::Matrix< double >* CasADi__kron_TIC(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);+ CasADi::Matrix< double > x1_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x1);++ return new CasADi::Matrix< double >( CasADi::kron(x0_, x1_) );+}+++// ================== function "CasADi::sparse''" ===============+// cppName: "CasADi::sparse''"+// cWrapperName: "CasADi__sparse_TIC_TIC"+// protoArgs: "(CasADi::Matrix< double >* x0, double x1)"+// params: [ConstRef (NonVec (CasadiClass DMatrix)),Val (NonVec CDouble)]+// args: "(x0_, x1_)"+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__sparse_TIC_TIC(CasADi::Matrix< double >* x0, double x1)"+// call: "CasADi::sparse(x0_, x1_)"+extern "C"+ CasADi::Matrix< double >* CasADi__sparse_TIC_TIC(CasADi::Matrix< double >* x0, double x1);+CasADi::Matrix< double >* CasADi__sparse_TIC_TIC(CasADi::Matrix< double >* x0, double x1){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);+ double x1_ = Marshaling<double,double>::marshal(x1);++ return new CasADi::Matrix< double >( CasADi::sparse(x0_, x1_) );+}+++// ================== function "CasADi::sparse'''" ===============+// cppName: "CasADi::sparse'''"+// cWrapperName: "CasADi__sparse_TIC_TIC_TIC"+// protoArgs: "(CasADi::Matrix< double >* x0)"+// params: [ConstRef (NonVec (CasadiClass DMatrix))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__sparse_TIC_TIC_TIC(CasADi::Matrix< double >* x0)"+// call: "CasADi::sparse(x0_)"+extern "C"+ CasADi::Matrix< double >* CasADi__sparse_TIC_TIC_TIC(CasADi::Matrix< double >* x0);+CasADi::Matrix< double >* CasADi__sparse_TIC_TIC_TIC(CasADi::Matrix< double >* x0){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);++ return new CasADi::Matrix< double >( CasADi::sparse(x0_) );+}+++// ================== function "CasADi::full'" ===============+// cppName: "CasADi::full'"+// cWrapperName: "CasADi__full_TIC"+// protoArgs: "(CasADi::Matrix< double >* x0)"+// params: [ConstRef (NonVec (CasadiClass DMatrix))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__full_TIC(CasADi::Matrix< double >* x0)"+// call: "CasADi::full(x0_)"+extern "C"+ CasADi::Matrix< double >* CasADi__full_TIC(CasADi::Matrix< double >* x0);+CasADi::Matrix< double >* CasADi__full_TIC(CasADi::Matrix< double >* x0){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);++ return new CasADi::Matrix< double >( CasADi::full(x0_) );+}+++// ================== function "CasADi::trans''" ===============+// cppName: "CasADi::trans''"+// cWrapperName: "CasADi__trans_TIC_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__trans_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0)"+// call: "CasADi::trans(x0_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__trans_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0);+CasADi::Matrix< CasADi::SX >* CasADi__trans_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);++ return new CasADi::Matrix< CasADi::SX >( CasADi::trans(x0_) );+}+++// ================== function "CasADi::mul''''''" ===============+// cppName: "CasADi::mul''''''"+// cWrapperName: "CasADi__mul_TIC_TIC_TIC_TIC_TIC_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::CRSSparsity* x2)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass CRSSparsity))]+// args: "(x0_, x1_, x2_)"+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__mul_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::CRSSparsity* x2)"+// call: "CasADi::mul(x0_, x1_, x2_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__mul_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::CRSSparsity* x2);+CasADi::Matrix< CasADi::SX >* CasADi__mul_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::CRSSparsity* x2){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);+ CasADi::Matrix< CasADi::SX > x1_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x1);+ CasADi::CRSSparsity x2_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x2);++ return new CasADi::Matrix< CasADi::SX >( CasADi::mul(x0_, x1_, x2_) );+}+++// ================== function "CasADi::mul'''''''" ===============+// cppName: "CasADi::mul'''''''"+// cWrapperName: "CasADi__mul_TIC_TIC_TIC_TIC_TIC_TIC_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass SXMatrix))]+// args: "(x0_, x1_)"+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__mul_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1)"+// call: "CasADi::mul(x0_, x1_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__mul_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1);+CasADi::Matrix< CasADi::SX >* CasADi__mul_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);+ CasADi::Matrix< CasADi::SX > x1_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x1);++ return new CasADi::Matrix< CasADi::SX >( CasADi::mul(x0_, x1_) );+}+++// ================== function "CasADi::mul''''''''" ===============+// cppName: "CasADi::mul''''''''"+// cWrapperName: "CasADi__mul_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"+// protoArgs: "(std::vector<CasADi::Matrix< CasADi::SX >* > * x0)"+// params: [ConstRef (Vec (NonVec (CasadiClass SXMatrix)))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__mul_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector<CasADi::Matrix< CasADi::SX >* > * x0)"+// call: "CasADi::mul(x0_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__mul_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector<CasADi::Matrix< CasADi::SX >* > * x0);+CasADi::Matrix< CasADi::SX >* CasADi__mul_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector<CasADi::Matrix< CasADi::SX >* > * x0){+ std::vector<CasADi::Matrix< CasADi::SX > > x0_ = Marshaling<std::vector<CasADi::Matrix< CasADi::SX > >,std::vector<CasADi::Matrix< CasADi::SX >* > *>::marshal(x0);++ return new CasADi::Matrix< CasADi::SX >( CasADi::mul(x0_) );+}+++// ================== function "CasADi::isConstant''" ===============+// cppName: "CasADi::isConstant''"+// cWrapperName: "CasADi__isConstant_TIC_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix))]+// args: "(x0_)"+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__isConstant_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0)"+// call: "CasADi::isConstant(x0_)"+extern "C"+ bool* CasADi__isConstant_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0);+bool* CasADi__isConstant_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);++ return new bool( CasADi::isConstant(x0_) );+}+++// ================== function "CasADi::isDense''" ===============+// cppName: "CasADi::isDense''"+// cWrapperName: "CasADi__isDense_TIC_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix))]+// args: "(x0_)"+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__isDense_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0)"+// call: "CasADi::isDense(x0_)"+extern "C"+ bool* CasADi__isDense_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0);+bool* CasADi__isDense_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);++ return new bool( CasADi::isDense(x0_) );+}+++// ================== function "CasADi::isEmpty''" ===============+// cppName: "CasADi::isEmpty''"+// cWrapperName: "CasADi__isEmpty_TIC_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix))]+// args: "(x0_)"+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__isEmpty_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0)"+// call: "CasADi::isEmpty(x0_)"+extern "C"+ bool* CasADi__isEmpty_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0);+bool* CasADi__isEmpty_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);++ return new bool( CasADi::isEmpty(x0_) );+}+++// ================== function "CasADi::isInteger''" ===============+// cppName: "CasADi::isInteger''"+// cWrapperName: "CasADi__isInteger_TIC_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix))]+// args: "(x0_)"+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__isInteger_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0)"+// call: "CasADi::isInteger(x0_)"+extern "C"+ bool* CasADi__isInteger_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0);+bool* CasADi__isInteger_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);++ return new bool( CasADi::isInteger(x0_) );+}+++// ================== function "CasADi::isScalar''" ===============+// cppName: "CasADi::isScalar''"+// cWrapperName: "CasADi__isScalar_TIC_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix))]+// args: "(x0_)"+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__isScalar_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0)"+// call: "CasADi::isScalar(x0_)"+extern "C"+ bool* CasADi__isScalar_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0);+bool* CasADi__isScalar_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);++ return new bool( CasADi::isScalar(x0_) );+}+++// ================== function "CasADi::isVector''" ===============+// cppName: "CasADi::isVector''"+// cWrapperName: "CasADi__isVector_TIC_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix))]+// args: "(x0_)"+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__isVector_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0)"+// call: "CasADi::isVector(x0_)"+extern "C"+ bool* CasADi__isVector_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0);+bool* CasADi__isVector_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);++ return new bool( CasADi::isVector(x0_) );+}+++// ================== function "CasADi::isTril''" ===============+// cppName: "CasADi::isTril''"+// cWrapperName: "CasADi__isTril_TIC_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix))]+// args: "(x0_)"+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__isTril_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0)"+// call: "CasADi::isTril(x0_)"+extern "C"+ bool* CasADi__isTril_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0);+bool* CasADi__isTril_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);++ return new bool( CasADi::isTril(x0_) );+}+++// ================== function "CasADi::isTriu''" ===============+// cppName: "CasADi::isTriu''"+// cWrapperName: "CasADi__isTriu_TIC_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix))]+// args: "(x0_)"+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__isTriu_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0)"+// call: "CasADi::isTriu(x0_)"+extern "C"+ bool* CasADi__isTriu_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0);+bool* CasADi__isTriu_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);++ return new bool( CasADi::isTriu(x0_) );+}+++// ================== function "CasADi::det''" ===============+// cppName: "CasADi::det''"+// cWrapperName: "CasADi__det_TIC_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::SX*"+// proto: "CasADi::SX* CasADi__det_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0)"+// call: "CasADi::det(x0_)"+extern "C"+ CasADi::SX* CasADi__det_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0);+CasADi::SX* CasADi__det_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);++ return new CasADi::SX( CasADi::det(x0_) );+}+++// ================== function "CasADi::getMinor''" ===============+// cppName: "CasADi::getMinor''"+// cWrapperName: "CasADi__getMinor_TIC_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, int x1, int x2)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix)),Val (NonVec CInt),Val (NonVec CInt)]+// args: "(x0_, x1_, x2_)"+// cWrapperRetType: "CasADi::SX*"+// proto: "CasADi::SX* CasADi__getMinor_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, int x1, int x2)"+// call: "CasADi::getMinor(x0_, x1_, x2_)"+extern "C"+ CasADi::SX* CasADi__getMinor_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, int x1, int x2);+CasADi::SX* CasADi__getMinor_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, int x1, int x2){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);+ int x2_ = Marshaling<int,int>::marshal(x2);++ return new CasADi::SX( CasADi::getMinor(x0_, x1_, x2_) );+}+++// ================== function "CasADi::cofactor''" ===============+// cppName: "CasADi::cofactor''"+// cWrapperName: "CasADi__cofactor_TIC_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, int x1, int x2)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix)),Val (NonVec CInt),Val (NonVec CInt)]+// args: "(x0_, x1_, x2_)"+// cWrapperRetType: "CasADi::SX*"+// proto: "CasADi::SX* CasADi__cofactor_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, int x1, int x2)"+// call: "CasADi::cofactor(x0_, x1_, x2_)"+extern "C"+ CasADi::SX* CasADi__cofactor_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, int x1, int x2);+CasADi::SX* CasADi__cofactor_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, int x1, int x2){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);+ int x2_ = Marshaling<int,int>::marshal(x2);++ return new CasADi::SX( CasADi::cofactor(x0_, x1_, x2_) );+}+++// ================== function "CasADi::adj''" ===============+// cppName: "CasADi::adj''"+// cWrapperName: "CasADi__adj_TIC_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__adj_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0)"+// call: "CasADi::adj(x0_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__adj_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0);+CasADi::Matrix< CasADi::SX >* CasADi__adj_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);++ return new CasADi::Matrix< CasADi::SX >( CasADi::adj(x0_) );+}+++// ================== function "CasADi::inv''" ===============+// cppName: "CasADi::inv''"+// cWrapperName: "CasADi__inv_TIC_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__inv_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0)"+// call: "CasADi::inv(x0_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__inv_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0);+CasADi::Matrix< CasADi::SX >* CasADi__inv_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);++ return new CasADi::Matrix< CasADi::SX >( CasADi::inv(x0_) );+}+++// ================== function "CasADi::reshape''''" ===============+// cppName: "CasADi::reshape''''"+// cWrapperName: "CasADi__reshape_TIC_TIC_TIC_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, int x1, int x2)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix)),Val (NonVec CInt),Val (NonVec CInt)]+// args: "(x0_, x1_, x2_)"+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__reshape_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, int x1, int x2)"+// call: "CasADi::reshape(x0_, x1_, x2_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__reshape_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, int x1, int x2);+CasADi::Matrix< CasADi::SX >* CasADi__reshape_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, int x1, int x2){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);+ int x2_ = Marshaling<int,int>::marshal(x2);++ return new CasADi::Matrix< CasADi::SX >( CasADi::reshape(x0_, x1_, x2_) );+}+++// ================== function "CasADi::reshape'''''" ===============+// cppName: "CasADi::reshape'''''"+// cWrapperName: "CasADi__reshape_TIC_TIC_TIC_TIC_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, CasADi::CRSSparsity* x1)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass CRSSparsity))]+// args: "(x0_, x1_)"+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__reshape_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::CRSSparsity* x1)"+// call: "CasADi::reshape(x0_, x1_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__reshape_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::CRSSparsity* x1);+CasADi::Matrix< CasADi::SX >* CasADi__reshape_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::CRSSparsity* x1){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);+ CasADi::CRSSparsity x1_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x1);++ return new CasADi::Matrix< CasADi::SX >( CasADi::reshape(x0_, x1_) );+}+++// ================== function "CasADi::vec''" ===============+// cppName: "CasADi::vec''"+// cWrapperName: "CasADi__vec_TIC_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__vec_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0)"+// call: "CasADi::vec(x0_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__vec_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0);+CasADi::Matrix< CasADi::SX >* CasADi__vec_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);++ return new CasADi::Matrix< CasADi::SX >( CasADi::vec(x0_) );+}+++// ================== function "CasADi::flatten''" ===============+// cppName: "CasADi::flatten''"+// cWrapperName: "CasADi__flatten_TIC_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__flatten_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0)"+// call: "CasADi::flatten(x0_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__flatten_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0);+CasADi::Matrix< CasADi::SX >* CasADi__flatten_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);++ return new CasADi::Matrix< CasADi::SX >( CasADi::flatten(x0_) );+}+++// ================== function "CasADi::vecNZ''" ===============+// cppName: "CasADi::vecNZ''"+// cWrapperName: "CasADi__vecNZ_TIC_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__vecNZ_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0)"+// call: "CasADi::vecNZ(x0_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__vecNZ_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0);+CasADi::Matrix< CasADi::SX >* CasADi__vecNZ_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);++ return new CasADi::Matrix< CasADi::SX >( CasADi::vecNZ(x0_) );+}+++// ================== function "CasADi::flattenNZ''" ===============+// cppName: "CasADi::flattenNZ''"+// cWrapperName: "CasADi__flattenNZ_TIC_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__flattenNZ_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0)"+// call: "CasADi::flattenNZ(x0_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__flattenNZ_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0);+CasADi::Matrix< CasADi::SX >* CasADi__flattenNZ_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);++ return new CasADi::Matrix< CasADi::SX >( CasADi::flattenNZ(x0_) );+}+++// ================== function "CasADi::blockcat''" ===============+// cppName: "CasADi::blockcat''"+// cWrapperName: "CasADi__blockcat_TIC_TIC"+// protoArgs: "(std::vector<std::vector<CasADi::Matrix< CasADi::SX >* > > * x0)"+// params: [ConstRef (Vec (Vec (NonVec (CasadiClass SXMatrix))))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__blockcat_TIC_TIC(std::vector<std::vector<CasADi::Matrix< CasADi::SX >* > > * x0)"+// call: "CasADi::blockcat(x0_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__blockcat_TIC_TIC(std::vector<std::vector<CasADi::Matrix< CasADi::SX >* > > * x0);+CasADi::Matrix< CasADi::SX >* CasADi__blockcat_TIC_TIC(std::vector<std::vector<CasADi::Matrix< CasADi::SX >* > > * x0){+ std::vector<std::vector<CasADi::Matrix< CasADi::SX > > > x0_ = Marshaling<std::vector<std::vector<CasADi::Matrix< CasADi::SX > > >,std::vector<std::vector<CasADi::Matrix< CasADi::SX >* > > *>::marshal(x0);++ return new CasADi::Matrix< CasADi::SX >( CasADi::blockcat(x0_) );+}+++// ================== function "CasADi::blocksplit''''''''" ===============+// cppName: "CasADi::blocksplit''''''''"+// cWrapperName: "CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, std::vector<int > * x1, std::vector<int > * x2)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (Vec (NonVec CInt)),ConstRef (Vec (NonVec CInt))]+// args: "(x0_, x1_, x2_)"+// cWrapperRetType: "std::vector<std::vector<CasADi::Matrix< CasADi::SX > > >*"+// proto: "std::vector<std::vector<CasADi::Matrix< CasADi::SX > > >* CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, std::vector<int > * x1, std::vector<int > * x2)"+// call: "CasADi::blocksplit(x0_, x1_, x2_)"+extern "C"+ std::vector<std::vector<CasADi::Matrix< CasADi::SX > > >* CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, std::vector<int > * x1, std::vector<int > * x2);+std::vector<std::vector<CasADi::Matrix< CasADi::SX > > >* CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, std::vector<int > * x1, std::vector<int > * x2){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);+ std::vector<int > x1_ = Marshaling<std::vector<int >,std::vector<int > *>::marshal(x1);+ std::vector<int > x2_ = Marshaling<std::vector<int >,std::vector<int > *>::marshal(x2);++ return new std::vector<std::vector<CasADi::Matrix< CasADi::SX > > >( CasADi::blocksplit(x0_, x1_, x2_) );+}+++// ================== function "CasADi::blocksplit'''''''''" ===============+// cppName: "CasADi::blocksplit'''''''''"+// cWrapperName: "CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, int x1, int x2)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix)),Val (NonVec CInt),Val (NonVec CInt)]+// args: "(x0_, x1_, x2_)"+// cWrapperRetType: "std::vector<std::vector<CasADi::Matrix< CasADi::SX > > >*"+// proto: "std::vector<std::vector<CasADi::Matrix< CasADi::SX > > >* CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, int x1, int x2)"+// call: "CasADi::blocksplit(x0_, x1_, x2_)"+extern "C"+ std::vector<std::vector<CasADi::Matrix< CasADi::SX > > >* CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, int x1, int x2);+std::vector<std::vector<CasADi::Matrix< CasADi::SX > > >* CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, int x1, int x2){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);+ int x2_ = Marshaling<int,int>::marshal(x2);++ return new std::vector<std::vector<CasADi::Matrix< CasADi::SX > > >( CasADi::blocksplit(x0_, x1_, x2_) );+}+++// ================== function "CasADi::blocksplit''''''''''" ===============+// cppName: "CasADi::blocksplit''''''''''"+// cWrapperName: "CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, int x1)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix)),Val (NonVec CInt)]+// args: "(x0_, x1_)"+// cWrapperRetType: "std::vector<std::vector<CasADi::Matrix< CasADi::SX > > >*"+// proto: "std::vector<std::vector<CasADi::Matrix< CasADi::SX > > >* CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, int x1)"+// call: "CasADi::blocksplit(x0_, x1_)"+extern "C"+ std::vector<std::vector<CasADi::Matrix< CasADi::SX > > >* CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, int x1);+std::vector<std::vector<CasADi::Matrix< CasADi::SX > > >* CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, int x1){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);++ return new std::vector<std::vector<CasADi::Matrix< CasADi::SX > > >( CasADi::blocksplit(x0_, x1_) );+}+++// ================== function "CasADi::blocksplit'''''''''''" ===============+// cppName: "CasADi::blocksplit'''''''''''"+// cWrapperName: "CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix))]+// args: "(x0_)"+// cWrapperRetType: "std::vector<std::vector<CasADi::Matrix< CasADi::SX > > >*"+// proto: "std::vector<std::vector<CasADi::Matrix< CasADi::SX > > >* CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0)"+// call: "CasADi::blocksplit(x0_)"+extern "C"+ std::vector<std::vector<CasADi::Matrix< CasADi::SX > > >* CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0);+std::vector<std::vector<CasADi::Matrix< CasADi::SX > > >* CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);++ return new std::vector<std::vector<CasADi::Matrix< CasADi::SX > > >( CasADi::blocksplit(x0_) );+}+++// ================== function "CasADi::horzcat''" ===============+// cppName: "CasADi::horzcat''"+// cWrapperName: "CasADi__horzcat_TIC_TIC"+// protoArgs: "(std::vector<CasADi::Matrix< CasADi::SX >* > * x0)"+// params: [ConstRef (Vec (NonVec (CasadiClass SXMatrix)))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__horzcat_TIC_TIC(std::vector<CasADi::Matrix< CasADi::SX >* > * x0)"+// call: "CasADi::horzcat(x0_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__horzcat_TIC_TIC(std::vector<CasADi::Matrix< CasADi::SX >* > * x0);+CasADi::Matrix< CasADi::SX >* CasADi__horzcat_TIC_TIC(std::vector<CasADi::Matrix< CasADi::SX >* > * x0){+ std::vector<CasADi::Matrix< CasADi::SX > > x0_ = Marshaling<std::vector<CasADi::Matrix< CasADi::SX > >,std::vector<CasADi::Matrix< CasADi::SX >* > *>::marshal(x0);++ return new CasADi::Matrix< CasADi::SX >( CasADi::horzcat(x0_) );+}+++// ================== function "CasADi::horzsplit''''''" ===============+// cppName: "CasADi::horzsplit''''''"+// cWrapperName: "CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, std::vector<int > * x1)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (Vec (NonVec CInt))]+// args: "(x0_, x1_)"+// cWrapperRetType: "std::vector<CasADi::Matrix< CasADi::SX > >*"+// proto: "std::vector<CasADi::Matrix< CasADi::SX > >* CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, std::vector<int > * x1)"+// call: "CasADi::horzsplit(x0_, x1_)"+extern "C"+ std::vector<CasADi::Matrix< CasADi::SX > >* CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, std::vector<int > * x1);+std::vector<CasADi::Matrix< CasADi::SX > >* CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, std::vector<int > * x1){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);+ std::vector<int > x1_ = Marshaling<std::vector<int >,std::vector<int > *>::marshal(x1);++ return new std::vector<CasADi::Matrix< CasADi::SX > >( CasADi::horzsplit(x0_, x1_) );+}+++// ================== function "CasADi::horzsplit'''''''" ===============+// cppName: "CasADi::horzsplit'''''''"+// cWrapperName: "CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, int x1)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix)),Val (NonVec CInt)]+// args: "(x0_, x1_)"+// cWrapperRetType: "std::vector<CasADi::Matrix< CasADi::SX > >*"+// proto: "std::vector<CasADi::Matrix< CasADi::SX > >* CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, int x1)"+// call: "CasADi::horzsplit(x0_, x1_)"+extern "C"+ std::vector<CasADi::Matrix< CasADi::SX > >* CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, int x1);+std::vector<CasADi::Matrix< CasADi::SX > >* CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, int x1){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);++ return new std::vector<CasADi::Matrix< CasADi::SX > >( CasADi::horzsplit(x0_, x1_) );+}+++// ================== function "CasADi::horzsplit''''''''" ===============+// cppName: "CasADi::horzsplit''''''''"+// cWrapperName: "CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix))]+// args: "(x0_)"+// cWrapperRetType: "std::vector<CasADi::Matrix< CasADi::SX > >*"+// proto: "std::vector<CasADi::Matrix< CasADi::SX > >* CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0)"+// call: "CasADi::horzsplit(x0_)"+extern "C"+ std::vector<CasADi::Matrix< CasADi::SX > >* CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0);+std::vector<CasADi::Matrix< CasADi::SX > >* CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);++ return new std::vector<CasADi::Matrix< CasADi::SX > >( CasADi::horzsplit(x0_) );+}+++// ================== function "CasADi::vertcat''" ===============+// cppName: "CasADi::vertcat''"+// cWrapperName: "CasADi__vertcat_TIC_TIC"+// protoArgs: "(std::vector<CasADi::Matrix< CasADi::SX >* > * x0)"+// params: [ConstRef (Vec (NonVec (CasadiClass SXMatrix)))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__vertcat_TIC_TIC(std::vector<CasADi::Matrix< CasADi::SX >* > * x0)"+// call: "CasADi::vertcat(x0_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__vertcat_TIC_TIC(std::vector<CasADi::Matrix< CasADi::SX >* > * x0);+CasADi::Matrix< CasADi::SX >* CasADi__vertcat_TIC_TIC(std::vector<CasADi::Matrix< CasADi::SX >* > * x0){+ std::vector<CasADi::Matrix< CasADi::SX > > x0_ = Marshaling<std::vector<CasADi::Matrix< CasADi::SX > >,std::vector<CasADi::Matrix< CasADi::SX >* > *>::marshal(x0);++ return new CasADi::Matrix< CasADi::SX >( CasADi::vertcat(x0_) );+}+++// ================== function "CasADi::vertsplit''''''" ===============+// cppName: "CasADi::vertsplit''''''"+// cWrapperName: "CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, std::vector<int > * x1)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (Vec (NonVec CInt))]+// args: "(x0_, x1_)"+// cWrapperRetType: "std::vector<CasADi::Matrix< CasADi::SX > >*"+// proto: "std::vector<CasADi::Matrix< CasADi::SX > >* CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, std::vector<int > * x1)"+// call: "CasADi::vertsplit(x0_, x1_)"+extern "C"+ std::vector<CasADi::Matrix< CasADi::SX > >* CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, std::vector<int > * x1);+std::vector<CasADi::Matrix< CasADi::SX > >* CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, std::vector<int > * x1){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);+ std::vector<int > x1_ = Marshaling<std::vector<int >,std::vector<int > *>::marshal(x1);++ return new std::vector<CasADi::Matrix< CasADi::SX > >( CasADi::vertsplit(x0_, x1_) );+}+++// ================== function "CasADi::vertsplit'''''''" ===============+// cppName: "CasADi::vertsplit'''''''"+// cWrapperName: "CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, int x1)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix)),Val (NonVec CInt)]+// args: "(x0_, x1_)"+// cWrapperRetType: "std::vector<CasADi::Matrix< CasADi::SX > >*"+// proto: "std::vector<CasADi::Matrix< CasADi::SX > >* CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, int x1)"+// call: "CasADi::vertsplit(x0_, x1_)"+extern "C"+ std::vector<CasADi::Matrix< CasADi::SX > >* CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, int x1);+std::vector<CasADi::Matrix< CasADi::SX > >* CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, int x1){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);++ return new std::vector<CasADi::Matrix< CasADi::SX > >( CasADi::vertsplit(x0_, x1_) );+}+++// ================== function "CasADi::vertsplit''''''''" ===============+// cppName: "CasADi::vertsplit''''''''"+// cWrapperName: "CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix))]+// args: "(x0_)"+// cWrapperRetType: "std::vector<CasADi::Matrix< CasADi::SX > >*"+// proto: "std::vector<CasADi::Matrix< CasADi::SX > >* CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0)"+// call: "CasADi::vertsplit(x0_)"+extern "C"+ std::vector<CasADi::Matrix< CasADi::SX > >* CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0);+std::vector<CasADi::Matrix< CasADi::SX > >* CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);++ return new std::vector<CasADi::Matrix< CasADi::SX > >( CasADi::vertsplit(x0_) );+}+++// ================== function "CasADi::inner_prod''" ===============+// cppName: "CasADi::inner_prod''"+// cWrapperName: "CasADi__inner_prod_TIC_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass SXMatrix))]+// args: "(x0_, x1_)"+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__inner_prod_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1)"+// call: "CasADi::inner_prod(x0_, x1_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__inner_prod_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1);+CasADi::Matrix< CasADi::SX >* CasADi__inner_prod_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);+ CasADi::Matrix< CasADi::SX > x1_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x1);++ return new CasADi::Matrix< CasADi::SX >( CasADi::inner_prod(x0_, x1_) );+}+++// ================== function "CasADi::outer_prod''" ===============+// cppName: "CasADi::outer_prod''"+// cWrapperName: "CasADi__outer_prod_TIC_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass SXMatrix))]+// args: "(x0_, x1_)"+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__outer_prod_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1)"+// call: "CasADi::outer_prod(x0_, x1_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__outer_prod_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1);+CasADi::Matrix< CasADi::SX >* CasADi__outer_prod_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);+ CasADi::Matrix< CasADi::SX > x1_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x1);++ return new CasADi::Matrix< CasADi::SX >( CasADi::outer_prod(x0_, x1_) );+}+++// ================== function "CasADi::norm_1''" ===============+// cppName: "CasADi::norm_1''"+// cWrapperName: "CasADi__norm_1_TIC_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__norm_1_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0)"+// call: "CasADi::norm_1(x0_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__norm_1_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0);+CasADi::Matrix< CasADi::SX >* CasADi__norm_1_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);++ return new CasADi::Matrix< CasADi::SX >( CasADi::norm_1(x0_) );+}+++// ================== function "CasADi::norm_2''" ===============+// cppName: "CasADi::norm_2''"+// cWrapperName: "CasADi__norm_2_TIC_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__norm_2_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0)"+// call: "CasADi::norm_2(x0_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__norm_2_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0);+CasADi::Matrix< CasADi::SX >* CasADi__norm_2_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);++ return new CasADi::Matrix< CasADi::SX >( CasADi::norm_2(x0_) );+}+++// ================== function "CasADi::norm_inf''" ===============+// cppName: "CasADi::norm_inf''"+// cWrapperName: "CasADi__norm_inf_TIC_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__norm_inf_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0)"+// call: "CasADi::norm_inf(x0_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__norm_inf_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0);+CasADi::Matrix< CasADi::SX >* CasADi__norm_inf_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);++ return new CasADi::Matrix< CasADi::SX >( CasADi::norm_inf(x0_) );+}+++// ================== function "CasADi::norm_F''" ===============+// cppName: "CasADi::norm_F''"+// cWrapperName: "CasADi__norm_F_TIC_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__norm_F_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0)"+// call: "CasADi::norm_F(x0_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__norm_F_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0);+CasADi::Matrix< CasADi::SX >* CasADi__norm_F_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);++ return new CasADi::Matrix< CasADi::SX >( CasADi::norm_F(x0_) );+}+++// ================== function "CasADi::qr''" ===============+// cppName: "CasADi::qr''"+// cWrapperName: "CasADi__qr_TIC_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix)),Ref (NonVec (CasadiClass SXMatrix)),Ref (NonVec (CasadiClass SXMatrix))]+// args: "(x0_, x1_, x2_)"+// cWrapperRetType: "void"+// proto: "void CasADi__qr_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2)"+// call: "CasADi::qr(x0_, x1_, x2_)"+extern "C"+ void CasADi__qr_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2);+void CasADi__qr_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);+ CasADi::Matrix< CasADi::SX > x1_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x1);+ CasADi::Matrix< CasADi::SX > x2_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x2);++ return CasADi::qr(x0_, x1_, x2_);+}+++// ================== function "CasADi::nullspace''" ===============+// cppName: "CasADi::nullspace''"+// cWrapperName: "CasADi__nullspace_TIC_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__nullspace_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0)"+// call: "CasADi::nullspace(x0_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__nullspace_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0);+CasADi::Matrix< CasADi::SX >* CasADi__nullspace_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);++ return new CasADi::Matrix< CasADi::SX >( CasADi::nullspace(x0_) );+}+++// ================== function "CasADi::solve''" ===============+// cppName: "CasADi::solve''"+// cWrapperName: "CasADi__solve_TIC_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass SXMatrix))]+// args: "(x0_, x1_)"+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__solve_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1)"+// call: "CasADi::solve(x0_, x1_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__solve_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1);+CasADi::Matrix< CasADi::SX >* CasADi__solve_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);+ CasADi::Matrix< CasADi::SX > x1_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x1);++ return new CasADi::Matrix< CasADi::SX >( CasADi::solve(x0_, x1_) );+}+++// ================== function "CasADi::pinv''" ===============+// cppName: "CasADi::pinv''"+// cWrapperName: "CasADi__pinv_TIC_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__pinv_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0)"+// call: "CasADi::pinv(x0_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__pinv_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0);+CasADi::Matrix< CasADi::SX >* CasADi__pinv_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);++ return new CasADi::Matrix< CasADi::SX >( CasADi::pinv(x0_) );+}+++// ================== function "CasADi::isZero''" ===============+// cppName: "CasADi::isZero''"+// cWrapperName: "CasADi__isZero_TIC_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix))]+// args: "(x0_)"+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__isZero_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0)"+// call: "CasADi::isZero(x0_)"+extern "C"+ bool* CasADi__isZero_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0);+bool* CasADi__isZero_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);++ return new bool( CasADi::isZero(x0_) );+}+++// ================== function "CasADi::isOne''" ===============+// cppName: "CasADi::isOne''"+// cWrapperName: "CasADi__isOne_TIC_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix))]+// args: "(x0_)"+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__isOne_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0)"+// call: "CasADi::isOne(x0_)"+extern "C"+ bool* CasADi__isOne_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0);+bool* CasADi__isOne_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);++ return new bool( CasADi::isOne(x0_) );+}+++// ================== function "CasADi::isMinusOne''" ===============+// cppName: "CasADi::isMinusOne''"+// cWrapperName: "CasADi__isMinusOne_TIC_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix))]+// args: "(x0_)"+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__isMinusOne_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0)"+// call: "CasADi::isMinusOne(x0_)"+extern "C"+ bool* CasADi__isMinusOne_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0);+bool* CasADi__isMinusOne_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);++ return new bool( CasADi::isMinusOne(x0_) );+}+++// ================== function "CasADi::isIdentity''" ===============+// cppName: "CasADi::isIdentity''"+// cWrapperName: "CasADi__isIdentity_TIC_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix))]+// args: "(x0_)"+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__isIdentity_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0)"+// call: "CasADi::isIdentity(x0_)"+extern "C"+ bool* CasADi__isIdentity_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0);+bool* CasADi__isIdentity_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);++ return new bool( CasADi::isIdentity(x0_) );+}+++// ================== function "CasADi::nnz''" ===============+// cppName: "CasADi::nnz''"+// cWrapperName: "CasADi__nnz_TIC_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix))]+// args: "(x0_)"+// cWrapperRetType: "int"+// proto: "int CasADi__nnz_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0)"+// call: "CasADi::nnz(x0_)"+extern "C"+ int CasADi__nnz_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0);+int CasADi__nnz_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);++ return CasADi::nnz(x0_);+}+++// ================== function "CasADi::nnz_sym''" ===============+// cppName: "CasADi::nnz_sym''"+// cWrapperName: "CasADi__nnz_sym_TIC_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix))]+// args: "(x0_)"+// cWrapperRetType: "int"+// proto: "int CasADi__nnz_sym_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0)"+// call: "CasADi::nnz_sym(x0_)"+extern "C"+ int CasADi__nnz_sym_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0);+int CasADi__nnz_sym_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);++ return CasADi::nnz_sym(x0_);+}+++// ================== function "CasADi::isEqual''" ===============+// cppName: "CasADi::isEqual''"+// cWrapperName: "CasADi__isEqual_TIC_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass SXMatrix))]+// args: "(x0_, x1_)"+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__isEqual_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1)"+// call: "CasADi::isEqual(x0_, x1_)"+extern "C"+ bool* CasADi__isEqual_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1);+bool* CasADi__isEqual_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);+ CasADi::Matrix< CasADi::SX > x1_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x1);++ return new bool( CasADi::isEqual(x0_, x1_) );+}+++// ================== function "CasADi::repmat''" ===============+// cppName: "CasADi::repmat''"+// cWrapperName: "CasADi__repmat_TIC_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, int x1, int x2)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix)),Val (NonVec CInt),Val (NonVec CInt)]+// args: "(x0_, x1_, x2_)"+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__repmat_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, int x1, int x2)"+// call: "CasADi::repmat(x0_, x1_, x2_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__repmat_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, int x1, int x2);+CasADi::Matrix< CasADi::SX >* CasADi__repmat_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, int x1, int x2){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);+ int x2_ = Marshaling<int,int>::marshal(x2);++ return new CasADi::Matrix< CasADi::SX >( CasADi::repmat(x0_, x1_, x2_) );+}+++// ================== function "CasADi::getSparseTriplet''" ===============+// cppName: "CasADi::getSparseTriplet''"+// cWrapperName: "CasADi__getSparseTriplet_TIC_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix))]+// args: "(x0_)"+// cWrapperRetType: "std::vector<std::vector<int > >*"+// proto: "std::vector<std::vector<int > >* CasADi__getSparseTriplet_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0)"+// call: "CasADi::getSparseTriplet(x0_)"+extern "C"+ std::vector<std::vector<int > >* CasADi__getSparseTriplet_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0);+std::vector<std::vector<int > >* CasADi__getSparseTriplet_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);++ return new std::vector<std::vector<int > >( CasADi::getSparseTriplet(x0_) );+}+++// ================== function "CasADi::unite''" ===============+// cppName: "CasADi::unite''"+// cWrapperName: "CasADi__unite_TIC_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass SXMatrix))]+// args: "(x0_, x1_)"+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__unite_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1)"+// call: "CasADi::unite(x0_, x1_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__unite_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1);+CasADi::Matrix< CasADi::SX >* CasADi__unite_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);+ CasADi::Matrix< CasADi::SX > x1_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x1);++ return new CasADi::Matrix< CasADi::SX >( CasADi::unite(x0_, x1_) );+}+++// ================== function "CasADi::sumCols''" ===============+// cppName: "CasADi::sumCols''"+// cWrapperName: "CasADi__sumCols_TIC_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__sumCols_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0)"+// call: "CasADi::sumCols(x0_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__sumCols_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0);+CasADi::Matrix< CasADi::SX >* CasADi__sumCols_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);++ return new CasADi::Matrix< CasADi::SX >( CasADi::sumCols(x0_) );+}+++// ================== function "CasADi::sumRows''" ===============+// cppName: "CasADi::sumRows''"+// cWrapperName: "CasADi__sumRows_TIC_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__sumRows_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0)"+// call: "CasADi::sumRows(x0_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__sumRows_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0);+CasADi::Matrix< CasADi::SX >* CasADi__sumRows_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);++ return new CasADi::Matrix< CasADi::SX >( CasADi::sumRows(x0_) );+}+++// ================== function "CasADi::sumAll''" ===============+// cppName: "CasADi::sumAll''"+// cWrapperName: "CasADi__sumAll_TIC_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__sumAll_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0)"+// call: "CasADi::sumAll(x0_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__sumAll_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0);+CasADi::Matrix< CasADi::SX >* CasADi__sumAll_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);++ return new CasADi::Matrix< CasADi::SX >( CasADi::sumAll(x0_) );+}+++// ================== function "CasADi::trace''" ===============+// cppName: "CasADi::trace''"+// cWrapperName: "CasADi__trace_TIC_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::SX*"+// proto: "CasADi::SX* CasADi__trace_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0)"+// call: "CasADi::trace(x0_)"+extern "C"+ CasADi::SX* CasADi__trace_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0);+CasADi::SX* CasADi__trace_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);++ return new CasADi::SX( CasADi::trace(x0_) );+}+++// ================== function "CasADi::makeDense''" ===============+// cppName: "CasADi::makeDense''"+// cWrapperName: "CasADi__makeDense_TIC_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"+// params: [Ref (NonVec (CasadiClass SXMatrix))]+// args: "(x0_)"+// cWrapperRetType: "void"+// proto: "void CasADi__makeDense_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0)"+// call: "CasADi::makeDense(x0_)"+extern "C"+ void CasADi__makeDense_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0);+void CasADi__makeDense_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);++ return CasADi::makeDense(x0_);+}+++// ================== function "CasADi::densify''" ===============+// cppName: "CasADi::densify''"+// cWrapperName: "CasADi__densify_TIC_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__densify_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0)"+// call: "CasADi::densify(x0_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__densify_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0);+CasADi::Matrix< CasADi::SX >* CasADi__densify_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);++ return new CasADi::Matrix< CasADi::SX >( CasADi::densify(x0_) );+}+++// ================== function "CasADi::makeSparse''''" ===============+// cppName: "CasADi::makeSparse''''"+// cWrapperName: "CasADi__makeSparse_TIC_TIC_TIC_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, double x1)"+// params: [Ref (NonVec (CasadiClass SXMatrix)),Val (NonVec CDouble)]+// args: "(x0_, x1_)"+// cWrapperRetType: "void"+// proto: "void CasADi__makeSparse_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, double x1)"+// call: "CasADi::makeSparse(x0_, x1_)"+extern "C"+ void CasADi__makeSparse_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, double x1);+void CasADi__makeSparse_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, double x1){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);+ double x1_ = Marshaling<double,double>::marshal(x1);++ return CasADi::makeSparse(x0_, x1_);+}+++// ================== function "CasADi::makeSparse'''''" ===============+// cppName: "CasADi::makeSparse'''''"+// cWrapperName: "CasADi__makeSparse_TIC_TIC_TIC_TIC_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"+// params: [Ref (NonVec (CasadiClass SXMatrix))]+// args: "(x0_)"+// cWrapperRetType: "void"+// proto: "void CasADi__makeSparse_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0)"+// call: "CasADi::makeSparse(x0_)"+extern "C"+ void CasADi__makeSparse_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0);+void CasADi__makeSparse_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);++ return CasADi::makeSparse(x0_);+}+++// ================== function "CasADi::hasNonStructuralZeros''" ===============+// cppName: "CasADi::hasNonStructuralZeros''"+// cWrapperName: "CasADi__hasNonStructuralZeros_TIC_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix))]+// args: "(x0_)"+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__hasNonStructuralZeros_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0)"+// call: "CasADi::hasNonStructuralZeros(x0_)"+extern "C"+ bool* CasADi__hasNonStructuralZeros_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0);+bool* CasADi__hasNonStructuralZeros_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);++ return new bool( CasADi::hasNonStructuralZeros(x0_) );+}+++// ================== function "CasADi::diag''" ===============+// cppName: "CasADi::diag''"+// cWrapperName: "CasADi__diag_TIC_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__diag_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0)"+// call: "CasADi::diag(x0_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__diag_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0);+CasADi::Matrix< CasADi::SX >* CasADi__diag_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);++ return new CasADi::Matrix< CasADi::SX >( CasADi::diag(x0_) );+}+++// ================== function "CasADi::blkdiag''" ===============+// cppName: "CasADi::blkdiag''"+// cWrapperName: "CasADi__blkdiag_TIC_TIC"+// protoArgs: "(std::vector<CasADi::Matrix< CasADi::SX >* > * x0)"+// params: [ConstRef (Vec (NonVec (CasadiClass SXMatrix)))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__blkdiag_TIC_TIC(std::vector<CasADi::Matrix< CasADi::SX >* > * x0)"+// call: "CasADi::blkdiag(x0_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__blkdiag_TIC_TIC(std::vector<CasADi::Matrix< CasADi::SX >* > * x0);+CasADi::Matrix< CasADi::SX >* CasADi__blkdiag_TIC_TIC(std::vector<CasADi::Matrix< CasADi::SX >* > * x0){+ std::vector<CasADi::Matrix< CasADi::SX > > x0_ = Marshaling<std::vector<CasADi::Matrix< CasADi::SX > >,std::vector<CasADi::Matrix< CasADi::SX >* > *>::marshal(x0);++ return new CasADi::Matrix< CasADi::SX >( CasADi::blkdiag(x0_) );+}+++// ================== function "CasADi::polyval''" ===============+// cppName: "CasADi::polyval''"+// cWrapperName: "CasADi__polyval_TIC_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass SXMatrix))]+// args: "(x0_, x1_)"+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__polyval_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1)"+// call: "CasADi::polyval(x0_, x1_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__polyval_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1);+CasADi::Matrix< CasADi::SX >* CasADi__polyval_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);+ CasADi::Matrix< CasADi::SX > x1_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x1);++ return new CasADi::Matrix< CasADi::SX >( CasADi::polyval(x0_, x1_) );+}+++// ================== function "CasADi::addMultiple''''" ===============+// cppName: "CasADi::addMultiple''''"+// cWrapperName: "CasADi__addMultiple_TIC_TIC_TIC_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, std::vector<CasADi::SX* > * x1, std::vector<CasADi::SX* >* x2, bool* x3)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (Vec (NonVec (CasadiClass SX))),Ref (Vec (NonVec (CasadiClass SX))),Val (NonVec CBool)]+// args: "(x0_, x1_, x2_, x3_)"+// cWrapperRetType: "void"+// proto: "void CasADi__addMultiple_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, std::vector<CasADi::SX* > * x1, std::vector<CasADi::SX* >* x2, bool* x3)"+// call: "CasADi::addMultiple(x0_, x1_, x2_, x3_)"+extern "C"+ void CasADi__addMultiple_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, std::vector<CasADi::SX* > * x1, std::vector<CasADi::SX* >* x2, bool* x3);+void CasADi__addMultiple_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, std::vector<CasADi::SX* > * x1, std::vector<CasADi::SX* >* x2, bool* x3){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);+ std::vector<CasADi::SX > x1_ = Marshaling<std::vector<CasADi::SX >,std::vector<CasADi::SX* > *>::marshal(x1);+ std::vector<CasADi::SX > x2_ = Marshaling<std::vector<CasADi::SX >,std::vector<CasADi::SX* >*>::marshal(x2);+ bool x3_ = Marshaling<bool,bool*>::marshal(x3);++ return CasADi::addMultiple(x0_, x1_, x2_, x3_);+}+++// ================== function "CasADi::addMultiple'''''" ===============+// cppName: "CasADi::addMultiple'''''"+// cWrapperName: "CasADi__addMultiple_TIC_TIC_TIC_TIC_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, std::vector<CasADi::SX* > * x1, std::vector<CasADi::SX* >* x2)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (Vec (NonVec (CasadiClass SX))),Ref (Vec (NonVec (CasadiClass SX)))]+// args: "(x0_, x1_, x2_)"+// cWrapperRetType: "void"+// proto: "void CasADi__addMultiple_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, std::vector<CasADi::SX* > * x1, std::vector<CasADi::SX* >* x2)"+// call: "CasADi::addMultiple(x0_, x1_, x2_)"+extern "C"+ void CasADi__addMultiple_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, std::vector<CasADi::SX* > * x1, std::vector<CasADi::SX* >* x2);+void CasADi__addMultiple_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, std::vector<CasADi::SX* > * x1, std::vector<CasADi::SX* >* x2){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);+ std::vector<CasADi::SX > x1_ = Marshaling<std::vector<CasADi::SX >,std::vector<CasADi::SX* > *>::marshal(x1);+ std::vector<CasADi::SX > x2_ = Marshaling<std::vector<CasADi::SX >,std::vector<CasADi::SX* >*>::marshal(x2);++ return CasADi::addMultiple(x0_, x1_, x2_);+}+++// ================== function "CasADi::veccat''" ===============+// cppName: "CasADi::veccat''"+// cWrapperName: "CasADi__veccat_TIC_TIC"+// protoArgs: "(std::vector<CasADi::Matrix< CasADi::SX >* > * x0)"+// params: [ConstRef (Vec (NonVec (CasadiClass SXMatrix)))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__veccat_TIC_TIC(std::vector<CasADi::Matrix< CasADi::SX >* > * x0)"+// call: "CasADi::veccat(x0_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__veccat_TIC_TIC(std::vector<CasADi::Matrix< CasADi::SX >* > * x0);+CasADi::Matrix< CasADi::SX >* CasADi__veccat_TIC_TIC(std::vector<CasADi::Matrix< CasADi::SX >* > * x0){+ std::vector<CasADi::Matrix< CasADi::SX > > x0_ = Marshaling<std::vector<CasADi::Matrix< CasADi::SX > >,std::vector<CasADi::Matrix< CasADi::SX >* > *>::marshal(x0);++ return new CasADi::Matrix< CasADi::SX >( CasADi::veccat(x0_) );+}+++// ================== function "CasADi::vecNZcat''" ===============+// cppName: "CasADi::vecNZcat''"+// cWrapperName: "CasADi__vecNZcat_TIC_TIC"+// protoArgs: "(std::vector<CasADi::Matrix< CasADi::SX >* > * x0)"+// params: [ConstRef (Vec (NonVec (CasadiClass SXMatrix)))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__vecNZcat_TIC_TIC(std::vector<CasADi::Matrix< CasADi::SX >* > * x0)"+// call: "CasADi::vecNZcat(x0_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__vecNZcat_TIC_TIC(std::vector<CasADi::Matrix< CasADi::SX >* > * x0);+CasADi::Matrix< CasADi::SX >* CasADi__vecNZcat_TIC_TIC(std::vector<CasADi::Matrix< CasADi::SX >* > * x0){+ std::vector<CasADi::Matrix< CasADi::SX > > x0_ = Marshaling<std::vector<CasADi::Matrix< CasADi::SX > >,std::vector<CasADi::Matrix< CasADi::SX >* > *>::marshal(x0);++ return new CasADi::Matrix< CasADi::SX >( CasADi::vecNZcat(x0_) );+}+++// ================== function "CasADi::flattencat''" ===============+// cppName: "CasADi::flattencat''"+// cWrapperName: "CasADi__flattencat_TIC_TIC"+// protoArgs: "(std::vector<CasADi::Matrix< CasADi::SX >* > * x0)"+// params: [ConstRef (Vec (NonVec (CasadiClass SXMatrix)))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__flattencat_TIC_TIC(std::vector<CasADi::Matrix< CasADi::SX >* > * x0)"+// call: "CasADi::flattencat(x0_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__flattencat_TIC_TIC(std::vector<CasADi::Matrix< CasADi::SX >* > * x0);+CasADi::Matrix< CasADi::SX >* CasADi__flattencat_TIC_TIC(std::vector<CasADi::Matrix< CasADi::SX >* > * x0){+ std::vector<CasADi::Matrix< CasADi::SX > > x0_ = Marshaling<std::vector<CasADi::Matrix< CasADi::SX > >,std::vector<CasADi::Matrix< CasADi::SX >* > *>::marshal(x0);++ return new CasADi::Matrix< CasADi::SX >( CasADi::flattencat(x0_) );+}+++// ================== function "CasADi::flattenNZcat''" ===============+// cppName: "CasADi::flattenNZcat''"+// cWrapperName: "CasADi__flattenNZcat_TIC_TIC"+// protoArgs: "(std::vector<CasADi::Matrix< CasADi::SX >* > * x0)"+// params: [ConstRef (Vec (NonVec (CasadiClass SXMatrix)))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__flattenNZcat_TIC_TIC(std::vector<CasADi::Matrix< CasADi::SX >* > * x0)"+// call: "CasADi::flattenNZcat(x0_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__flattenNZcat_TIC_TIC(std::vector<CasADi::Matrix< CasADi::SX >* > * x0);+CasADi::Matrix< CasADi::SX >* CasADi__flattenNZcat_TIC_TIC(std::vector<CasADi::Matrix< CasADi::SX >* > * x0){+ std::vector<CasADi::Matrix< CasADi::SX > > x0_ = Marshaling<std::vector<CasADi::Matrix< CasADi::SX > >,std::vector<CasADi::Matrix< CasADi::SX >* > *>::marshal(x0);++ return new CasADi::Matrix< CasADi::SX >( CasADi::flattenNZcat(x0_) );+}+++// ================== function "CasADi::project''" ===============+// cppName: "CasADi::project''"+// cWrapperName: "CasADi__project_TIC_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, CasADi::CRSSparsity* x1)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass CRSSparsity))]+// args: "(x0_, x1_)"+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__project_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::CRSSparsity* x1)"+// call: "CasADi::project(x0_, x1_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__project_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::CRSSparsity* x1);+CasADi::Matrix< CasADi::SX >* CasADi__project_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::CRSSparsity* x1){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);+ CasADi::CRSSparsity x1_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x1);++ return new CasADi::Matrix< CasADi::SX >( CasADi::project(x0_, x1_) );+}+++// ================== function "CasADi::sprank''" ===============+// cppName: "CasADi::sprank''"+// cWrapperName: "CasADi__sprank_TIC_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix))]+// args: "(x0_)"+// cWrapperRetType: "int"+// proto: "int CasADi__sprank_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0)"+// call: "CasADi::sprank(x0_)"+extern "C"+ int CasADi__sprank_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0);+int CasADi__sprank_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);++ return CasADi::sprank(x0_);+}+++// ================== function "CasADi::kron''" ===============+// cppName: "CasADi::kron''"+// cWrapperName: "CasADi__kron_TIC_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass SXMatrix))]+// args: "(x0_, x1_)"+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__kron_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1)"+// call: "CasADi::kron(x0_, x1_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__kron_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1);+CasADi::Matrix< CasADi::SX >* CasADi__kron_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);+ CasADi::Matrix< CasADi::SX > x1_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x1);++ return new CasADi::Matrix< CasADi::SX >( CasADi::kron(x0_, x1_) );+}+++// ================== function "CasADi::sparse''''" ===============+// cppName: "CasADi::sparse''''"+// cWrapperName: "CasADi__sparse_TIC_TIC_TIC_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, double x1)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix)),Val (NonVec CDouble)]+// args: "(x0_, x1_)"+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__sparse_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, double x1)"+// call: "CasADi::sparse(x0_, x1_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__sparse_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, double x1);+CasADi::Matrix< CasADi::SX >* CasADi__sparse_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, double x1){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);+ double x1_ = Marshaling<double,double>::marshal(x1);++ return new CasADi::Matrix< CasADi::SX >( CasADi::sparse(x0_, x1_) );+}+++// ================== function "CasADi::sparse'''''" ===============+// cppName: "CasADi::sparse'''''"+// cWrapperName: "CasADi__sparse_TIC_TIC_TIC_TIC_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__sparse_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0)"+// call: "CasADi::sparse(x0_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__sparse_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0);+CasADi::Matrix< CasADi::SX >* CasADi__sparse_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);++ return new CasADi::Matrix< CasADi::SX >( CasADi::sparse(x0_) );+}+++// ================== function "CasADi::full''" ===============+// cppName: "CasADi::full''"+// cWrapperName: "CasADi__full_TIC_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__full_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0)"+// call: "CasADi::full(x0_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__full_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0);+CasADi::Matrix< CasADi::SX >* CasADi__full_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);++ return new CasADi::Matrix< CasADi::SX >( CasADi::full(x0_) );+}+++// ================== function "CasADi::logic_and" ===============+// cppName: "CasADi::logic_and"+// cWrapperName: "CasADi__logic_and"+// protoArgs: "(int* x0, int* x1)"+// params: [ConstRef (NonVec CInt),ConstRef (NonVec CInt)]+// args: "(x0_, x1_)"+// cWrapperRetType: "int"+// proto: "int CasADi__logic_and(int* x0, int* x1)"+// call: "CasADi::logic_and(x0_, x1_)"+extern "C"+ int CasADi__logic_and(int* x0, int* x1);+int CasADi__logic_and(int* x0, int* x1){+ int x0_ = Marshaling<int,int*>::marshal(x0);+ int x1_ = Marshaling<int,int*>::marshal(x1);++ return CasADi::logic_and(x0_, x1_);+}+++// ================== function "CasADi::logic_or" ===============+// cppName: "CasADi::logic_or"+// cWrapperName: "CasADi__logic_or"+// protoArgs: "(int* x0, int* x1)"+// params: [ConstRef (NonVec CInt),ConstRef (NonVec CInt)]+// args: "(x0_, x1_)"+// cWrapperRetType: "int"+// proto: "int CasADi__logic_or(int* x0, int* x1)"+// call: "CasADi::logic_or(x0_, x1_)"+extern "C"+ int CasADi__logic_or(int* x0, int* x1);+int CasADi__logic_or(int* x0, int* x1){+ int x0_ = Marshaling<int,int*>::marshal(x0);+ int x1_ = Marshaling<int,int*>::marshal(x1);++ return CasADi::logic_or(x0_, x1_);+}+++// ================== function "CasADi::logic_not" ===============+// cppName: "CasADi::logic_not"+// cWrapperName: "CasADi__logic_not"+// protoArgs: "(int* x0)"+// params: [ConstRef (NonVec CInt)]+// args: "(x0_)"+// cWrapperRetType: "int"+// proto: "int CasADi__logic_not(int* x0)"+// call: "CasADi::logic_not(x0_)"+extern "C"+ int CasADi__logic_not(int* x0);+int CasADi__logic_not(int* x0){+ int x0_ = Marshaling<int,int*>::marshal(x0);++ return CasADi::logic_not(x0_);+}+++// ================== function "CasADi::logic_and'" ===============+// cppName: "CasADi::logic_and'"+// cWrapperName: "CasADi__logic_and_TIC"+// protoArgs: "(double* x0, double* x1)"+// params: [ConstRef (NonVec CDouble),ConstRef (NonVec CDouble)]+// args: "(x0_, x1_)"+// cWrapperRetType: "double"+// proto: "double CasADi__logic_and_TIC(double* x0, double* x1)"+// call: "CasADi::logic_and(x0_, x1_)"+extern "C"+ double CasADi__logic_and_TIC(double* x0, double* x1);+double CasADi__logic_and_TIC(double* x0, double* x1){+ double x0_ = Marshaling<double,double*>::marshal(x0);+ double x1_ = Marshaling<double,double*>::marshal(x1);++ return CasADi::logic_and(x0_, x1_);+}+++// ================== function "CasADi::logic_or'" ===============+// cppName: "CasADi::logic_or'"+// cWrapperName: "CasADi__logic_or_TIC"+// protoArgs: "(double* x0, double* x1)"+// params: [ConstRef (NonVec CDouble),ConstRef (NonVec CDouble)]+// args: "(x0_, x1_)"+// cWrapperRetType: "double"+// proto: "double CasADi__logic_or_TIC(double* x0, double* x1)"+// call: "CasADi::logic_or(x0_, x1_)"+extern "C"+ double CasADi__logic_or_TIC(double* x0, double* x1);+double CasADi__logic_or_TIC(double* x0, double* x1){+ double x0_ = Marshaling<double,double*>::marshal(x0);+ double x1_ = Marshaling<double,double*>::marshal(x1);++ return CasADi::logic_or(x0_, x1_);+}+++// ================== function "CasADi::logic_not'" ===============+// cppName: "CasADi::logic_not'"+// cWrapperName: "CasADi__logic_not_TIC"+// protoArgs: "(double* x0)"+// params: [ConstRef (NonVec CDouble)]+// args: "(x0_)"+// cWrapperRetType: "double"+// proto: "double CasADi__logic_not_TIC(double* x0)"+// call: "CasADi::logic_not(x0_)"+extern "C"+ double CasADi__logic_not_TIC(double* x0);+double CasADi__logic_not_TIC(double* x0){+ double x0_ = Marshaling<double,double*>::marshal(x0);++ return CasADi::logic_not(x0_);+}+++// ================== function "CasADi::logic_and'''" ===============+// cppName: "CasADi::logic_and'''"+// cWrapperName: "CasADi__logic_and_TIC_TIC_TIC"+// protoArgs: "(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1)"+// params: [ConstRef (NonVec (CasadiClass DMatrix)),ConstRef (NonVec (CasadiClass DMatrix))]+// args: "(x0_, x1_)"+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__logic_and_TIC_TIC_TIC(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1)"+// call: "CasADi::logic_and(x0_, x1_)"+extern "C"+ CasADi::Matrix< double >* CasADi__logic_and_TIC_TIC_TIC(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1);+CasADi::Matrix< double >* CasADi__logic_and_TIC_TIC_TIC(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);+ CasADi::Matrix< double > x1_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x1);++ return new CasADi::Matrix< double >( CasADi::logic_and(x0_, x1_) );+}+++// ================== function "CasADi::logic_or'''" ===============+// cppName: "CasADi::logic_or'''"+// cWrapperName: "CasADi__logic_or_TIC_TIC_TIC"+// protoArgs: "(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1)"+// params: [ConstRef (NonVec (CasadiClass DMatrix)),ConstRef (NonVec (CasadiClass DMatrix))]+// args: "(x0_, x1_)"+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__logic_or_TIC_TIC_TIC(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1)"+// call: "CasADi::logic_or(x0_, x1_)"+extern "C"+ CasADi::Matrix< double >* CasADi__logic_or_TIC_TIC_TIC(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1);+CasADi::Matrix< double >* CasADi__logic_or_TIC_TIC_TIC(CasADi::Matrix< double >* x0, CasADi::Matrix< double >* x1){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);+ CasADi::Matrix< double > x1_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x1);++ return new CasADi::Matrix< double >( CasADi::logic_or(x0_, x1_) );+}+++// ================== function "CasADi::logic_not'''" ===============+// cppName: "CasADi::logic_not'''"+// cWrapperName: "CasADi__logic_not_TIC_TIC_TIC"+// protoArgs: "(CasADi::Matrix< double >* x0)"+// params: [ConstRef (NonVec (CasadiClass DMatrix))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__logic_not_TIC_TIC_TIC(CasADi::Matrix< double >* x0)"+// call: "CasADi::logic_not(x0_)"+extern "C"+ CasADi::Matrix< double >* CasADi__logic_not_TIC_TIC_TIC(CasADi::Matrix< double >* x0);+CasADi::Matrix< double >* CasADi__logic_not_TIC_TIC_TIC(CasADi::Matrix< double >* x0){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);++ return new CasADi::Matrix< double >( CasADi::logic_not(x0_) );+}+++// ================== function "CasADi::logic_and''''" ===============+// cppName: "CasADi::logic_and''''"+// cWrapperName: "CasADi__logic_and_TIC_TIC_TIC_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass SXMatrix))]+// args: "(x0_, x1_)"+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__logic_and_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1)"+// call: "CasADi::logic_and(x0_, x1_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__logic_and_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1);+CasADi::Matrix< CasADi::SX >* CasADi__logic_and_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);+ CasADi::Matrix< CasADi::SX > x1_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x1);++ return new CasADi::Matrix< CasADi::SX >( CasADi::logic_and(x0_, x1_) );+}+++// ================== function "CasADi::logic_or''''" ===============+// cppName: "CasADi::logic_or''''"+// cWrapperName: "CasADi__logic_or_TIC_TIC_TIC_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass SXMatrix))]+// args: "(x0_, x1_)"+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__logic_or_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1)"+// call: "CasADi::logic_or(x0_, x1_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__logic_or_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1);+CasADi::Matrix< CasADi::SX >* CasADi__logic_or_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);+ CasADi::Matrix< CasADi::SX > x1_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x1);++ return new CasADi::Matrix< CasADi::SX >( CasADi::logic_or(x0_, x1_) );+}+++// ================== function "CasADi::logic_not''''" ===============+// cppName: "CasADi::logic_not''''"+// cWrapperName: "CasADi__logic_not_TIC_TIC_TIC_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__logic_not_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0)"+// call: "CasADi::logic_not(x0_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__logic_not_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0);+CasADi::Matrix< CasADi::SX >* CasADi__logic_not_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);++ return new CasADi::Matrix< CasADi::SX >( CasADi::logic_not(x0_) );+}+++// ================== function "CasADi::logic_and'''''" ===============+// cppName: "CasADi::logic_and'''''"+// cWrapperName: "CasADi__logic_and_TIC_TIC_TIC_TIC_TIC"+// protoArgs: "(CasADi::MX* x0, CasADi::MX* x1)"+// params: [ConstRef (NonVec (CasadiClass MX)),ConstRef (NonVec (CasadiClass MX))]+// args: "(x0_, x1_)"+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__logic_and_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0, CasADi::MX* x1)"+// call: "CasADi::logic_and(x0_, x1_)"+extern "C"+ CasADi::MX* CasADi__logic_and_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0, CasADi::MX* x1);+CasADi::MX* CasADi__logic_and_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0, CasADi::MX* x1){+ CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);+ CasADi::MX x1_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x1);++ return new CasADi::MX( CasADi::logic_and(x0_, x1_) );+}+++// ================== function "CasADi::logic_or'''''" ===============+// cppName: "CasADi::logic_or'''''"+// cWrapperName: "CasADi__logic_or_TIC_TIC_TIC_TIC_TIC"+// protoArgs: "(CasADi::MX* x0, CasADi::MX* x1)"+// params: [ConstRef (NonVec (CasadiClass MX)),ConstRef (NonVec (CasadiClass MX))]+// args: "(x0_, x1_)"+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__logic_or_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0, CasADi::MX* x1)"+// call: "CasADi::logic_or(x0_, x1_)"+extern "C"+ CasADi::MX* CasADi__logic_or_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0, CasADi::MX* x1);+CasADi::MX* CasADi__logic_or_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0, CasADi::MX* x1){+ CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);+ CasADi::MX x1_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x1);++ return new CasADi::MX( CasADi::logic_or(x0_, x1_) );+}+++// ================== function "CasADi::logic_not'''''" ===============+// cppName: "CasADi::logic_not'''''"+// cWrapperName: "CasADi__logic_not_TIC_TIC_TIC_TIC_TIC"+// protoArgs: "(CasADi::MX* x0)"+// params: [ConstRef (NonVec (CasadiClass MX))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__logic_not_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0)"+// call: "CasADi::logic_not(x0_)"+extern "C"+ CasADi::MX* CasADi__logic_not_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0);+CasADi::MX* CasADi__logic_not_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0){+ CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);++ return new CasADi::MX( CasADi::logic_not(x0_) );+}+++// ================== function "CasADi::logic_and''''''" ===============+// cppName: "CasADi::logic_and''''''"+// cWrapperName: "CasADi__logic_and_TIC_TIC_TIC_TIC_TIC_TIC"+// protoArgs: "(CasADi::SX* x0, CasADi::SX* x1)"+// params: [ConstRef (NonVec (CasadiClass SX)),ConstRef (NonVec (CasadiClass SX))]+// args: "(x0_, x1_)"+// cWrapperRetType: "CasADi::SX*"+// proto: "CasADi::SX* CasADi__logic_and_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::SX* x0, CasADi::SX* x1)"+// call: "CasADi::logic_and(x0_, x1_)"+extern "C"+ CasADi::SX* CasADi__logic_and_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::SX* x0, CasADi::SX* x1);+CasADi::SX* CasADi__logic_and_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::SX* x0, CasADi::SX* x1){+ CasADi::SX x0_ = Marshaling<CasADi::SX,CasADi::SX*>::marshal(x0);+ CasADi::SX x1_ = Marshaling<CasADi::SX,CasADi::SX*>::marshal(x1);++ return new CasADi::SX( CasADi::logic_and(x0_, x1_) );+}+++// ================== function "CasADi::logic_or''''''" ===============+// cppName: "CasADi::logic_or''''''"+// cWrapperName: "CasADi__logic_or_TIC_TIC_TIC_TIC_TIC_TIC"+// protoArgs: "(CasADi::SX* x0, CasADi::SX* x1)"+// params: [ConstRef (NonVec (CasadiClass SX)),ConstRef (NonVec (CasadiClass SX))]+// args: "(x0_, x1_)"+// cWrapperRetType: "CasADi::SX*"+// proto: "CasADi::SX* CasADi__logic_or_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::SX* x0, CasADi::SX* x1)"+// call: "CasADi::logic_or(x0_, x1_)"+extern "C"+ CasADi::SX* CasADi__logic_or_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::SX* x0, CasADi::SX* x1);+CasADi::SX* CasADi__logic_or_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::SX* x0, CasADi::SX* x1){+ CasADi::SX x0_ = Marshaling<CasADi::SX,CasADi::SX*>::marshal(x0);+ CasADi::SX x1_ = Marshaling<CasADi::SX,CasADi::SX*>::marshal(x1);++ return new CasADi::SX( CasADi::logic_or(x0_, x1_) );+}+++// ================== function "CasADi::logic_not''''''" ===============+// cppName: "CasADi::logic_not''''''"+// cWrapperName: "CasADi__logic_not_TIC_TIC_TIC_TIC_TIC_TIC"+// protoArgs: "(CasADi::SX* x0)"+// params: [ConstRef (NonVec (CasadiClass SX))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::SX*"+// proto: "CasADi::SX* CasADi__logic_not_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::SX* x0)"+// call: "CasADi::logic_not(x0_)"+extern "C"+ CasADi::SX* CasADi__logic_not_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::SX* x0);+CasADi::SX* CasADi__logic_not_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::SX* x0){+ CasADi::SX x0_ = Marshaling<CasADi::SX,CasADi::SX*>::marshal(x0);++ return new CasADi::SX( CasADi::logic_not(x0_) );+}+++// ================== function "CasADi::hash_combine" ===============+// cppName: "CasADi::hash_combine"+// cWrapperName: "CasADi__hash_combine"+// protoArgs: "(size_t* x0, std::vector<int > * x1)"+// params: [Ref (NonVec CSize),ConstRef (Vec (NonVec CInt))]+// args: "(x0_, x1_)"+// cWrapperRetType: "void"+// proto: "void CasADi__hash_combine(size_t* x0, std::vector<int > * x1)"+// call: "CasADi::hash_combine(x0_, x1_)"+extern "C"+ void CasADi__hash_combine(size_t* x0, std::vector<int > * x1);+void CasADi__hash_combine(size_t* x0, std::vector<int > * x1){+ size_t x0_ = Marshaling<size_t,size_t*>::marshal(x0);+ std::vector<int > x1_ = Marshaling<std::vector<int >,std::vector<int > *>::marshal(x1);++ return CasADi::hash_combine(x0_, x1_);+}+++// ================== function "CasADi::hash_sparsity" ===============+// cppName: "CasADi::hash_sparsity"+// cWrapperName: "CasADi__hash_sparsity"+// protoArgs: "(int x0, int x1, std::vector<int > * x2, std::vector<int > * x3)"+// params: [Val (NonVec CInt),Val (NonVec CInt),ConstRef (Vec (NonVec CInt)),ConstRef (Vec (NonVec CInt))]+// args: "(x0_, x1_, x2_, x3_)"+// cWrapperRetType: "size_t"+// proto: "size_t CasADi__hash_sparsity(int x0, int x1, std::vector<int > * x2, std::vector<int > * x3)"+// call: "CasADi::hash_sparsity(x0_, x1_, x2_, x3_)"+extern "C"+ size_t CasADi__hash_sparsity(int x0, int x1, std::vector<int > * x2, std::vector<int > * x3);+size_t CasADi__hash_sparsity(int x0, int x1, std::vector<int > * x2, std::vector<int > * x3){+ int x0_ = Marshaling<int,int>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);+ std::vector<int > x2_ = Marshaling<std::vector<int >,std::vector<int > *>::marshal(x2);+ std::vector<int > x3_ = Marshaling<std::vector<int >,std::vector<int > *>::marshal(x3);++ return CasADi::hash_sparsity(x0_, x1_, x2_, x3_);+}+++// ================== function "CasADi::sp_dense" ===============+// cppName: "CasADi::sp_dense"+// cWrapperName: "CasADi__sp_dense"+// protoArgs: "(int x0, int x1)"+// params: [Val (NonVec CInt),Val (NonVec CInt)]+// args: "(x0_, x1_)"+// cWrapperRetType: "CasADi::CRSSparsity*"+// proto: "CasADi::CRSSparsity* CasADi__sp_dense(int x0, int x1)"+// call: "CasADi::sp_dense(x0_, x1_)"+extern "C"+ CasADi::CRSSparsity* CasADi__sp_dense(int x0, int x1);+CasADi::CRSSparsity* CasADi__sp_dense(int x0, int x1){+ int x0_ = Marshaling<int,int>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);++ return new CasADi::CRSSparsity( CasADi::sp_dense(x0_, x1_) );+}+++// ================== function "CasADi::sp_dense'" ===============+// cppName: "CasADi::sp_dense'"+// cWrapperName: "CasADi__sp_dense_TIC"+// protoArgs: "(int x0)"+// params: [Val (NonVec CInt)]+// args: "(x0_)"+// cWrapperRetType: "CasADi::CRSSparsity*"+// proto: "CasADi::CRSSparsity* CasADi__sp_dense_TIC(int x0)"+// call: "CasADi::sp_dense(x0_)"+extern "C"+ CasADi::CRSSparsity* CasADi__sp_dense_TIC(int x0);+CasADi::CRSSparsity* CasADi__sp_dense_TIC(int x0){+ int x0_ = Marshaling<int,int>::marshal(x0);++ return new CasADi::CRSSparsity( CasADi::sp_dense(x0_) );+}+++// ================== function "CasADi::sp_sparse" ===============+// cppName: "CasADi::sp_sparse"+// cWrapperName: "CasADi__sp_sparse"+// protoArgs: "(int x0, int x1)"+// params: [Val (NonVec CInt),Val (NonVec CInt)]+// args: "(x0_, x1_)"+// cWrapperRetType: "CasADi::CRSSparsity*"+// proto: "CasADi::CRSSparsity* CasADi__sp_sparse(int x0, int x1)"+// call: "CasADi::sp_sparse(x0_, x1_)"+extern "C"+ CasADi::CRSSparsity* CasADi__sp_sparse(int x0, int x1);+CasADi::CRSSparsity* CasADi__sp_sparse(int x0, int x1){+ int x0_ = Marshaling<int,int>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);++ return new CasADi::CRSSparsity( CasADi::sp_sparse(x0_, x1_) );+}+++// ================== function "CasADi::sp_sparse'" ===============+// cppName: "CasADi::sp_sparse'"+// cWrapperName: "CasADi__sp_sparse_TIC"+// protoArgs: "(int x0)"+// params: [Val (NonVec CInt)]+// args: "(x0_)"+// cWrapperRetType: "CasADi::CRSSparsity*"+// proto: "CasADi::CRSSparsity* CasADi__sp_sparse_TIC(int x0)"+// call: "CasADi::sp_sparse(x0_)"+extern "C"+ CasADi::CRSSparsity* CasADi__sp_sparse_TIC(int x0);+CasADi::CRSSparsity* CasADi__sp_sparse_TIC(int x0){+ int x0_ = Marshaling<int,int>::marshal(x0);++ return new CasADi::CRSSparsity( CasADi::sp_sparse(x0_) );+}+++// ================== function "CasADi::sp_unit" ===============+// cppName: "CasADi::sp_unit"+// cWrapperName: "CasADi__sp_unit"+// protoArgs: "(int x0, int x1)"+// params: [Val (NonVec CInt),Val (NonVec CInt)]+// args: "(x0_, x1_)"+// cWrapperRetType: "CasADi::CRSSparsity*"+// proto: "CasADi::CRSSparsity* CasADi__sp_unit(int x0, int x1)"+// call: "CasADi::sp_unit(x0_, x1_)"+extern "C"+ CasADi::CRSSparsity* CasADi__sp_unit(int x0, int x1);+CasADi::CRSSparsity* CasADi__sp_unit(int x0, int x1){+ int x0_ = Marshaling<int,int>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);++ return new CasADi::CRSSparsity( CasADi::sp_unit(x0_, x1_) );+}+++// ================== function "CasADi::sp_tril" ===============+// cppName: "CasADi::sp_tril"+// cWrapperName: "CasADi__sp_tril"+// protoArgs: "(int x0)"+// params: [Val (NonVec CInt)]+// args: "(x0_)"+// cWrapperRetType: "CasADi::CRSSparsity*"+// proto: "CasADi::CRSSparsity* CasADi__sp_tril(int x0)"+// call: "CasADi::sp_tril(x0_)"+extern "C"+ CasADi::CRSSparsity* CasADi__sp_tril(int x0);+CasADi::CRSSparsity* CasADi__sp_tril(int x0){+ int x0_ = Marshaling<int,int>::marshal(x0);++ return new CasADi::CRSSparsity( CasADi::sp_tril(x0_) );+}+++// ================== function "CasADi::sp_diag" ===============+// cppName: "CasADi::sp_diag"+// cWrapperName: "CasADi__sp_diag"+// protoArgs: "(int x0)"+// params: [Val (NonVec CInt)]+// args: "(x0_)"+// cWrapperRetType: "CasADi::CRSSparsity*"+// proto: "CasADi::CRSSparsity* CasADi__sp_diag(int x0)"+// call: "CasADi::sp_diag(x0_)"+extern "C"+ CasADi::CRSSparsity* CasADi__sp_diag(int x0);+CasADi::CRSSparsity* CasADi__sp_diag(int x0){+ int x0_ = Marshaling<int,int>::marshal(x0);++ return new CasADi::CRSSparsity( CasADi::sp_diag(x0_) );+}+++// ================== function "CasADi::sp_band" ===============+// cppName: "CasADi::sp_band"+// cWrapperName: "CasADi__sp_band"+// protoArgs: "(int x0, int x1)"+// params: [Val (NonVec CInt),Val (NonVec CInt)]+// args: "(x0_, x1_)"+// cWrapperRetType: "CasADi::CRSSparsity*"+// proto: "CasADi::CRSSparsity* CasADi__sp_band(int x0, int x1)"+// call: "CasADi::sp_band(x0_, x1_)"+extern "C"+ CasADi::CRSSparsity* CasADi__sp_band(int x0, int x1);+CasADi::CRSSparsity* CasADi__sp_band(int x0, int x1){+ int x0_ = Marshaling<int,int>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);++ return new CasADi::CRSSparsity( CasADi::sp_band(x0_, x1_) );+}+++// ================== function "CasADi::sp_banded" ===============+// cppName: "CasADi::sp_banded"+// cWrapperName: "CasADi__sp_banded"+// protoArgs: "(int x0, int x1)"+// params: [Val (NonVec CInt),Val (NonVec CInt)]+// args: "(x0_, x1_)"+// cWrapperRetType: "CasADi::CRSSparsity*"+// proto: "CasADi::CRSSparsity* CasADi__sp_banded(int x0, int x1)"+// call: "CasADi::sp_banded(x0_, x1_)"+extern "C"+ CasADi::CRSSparsity* CasADi__sp_banded(int x0, int x1);+CasADi::CRSSparsity* CasADi__sp_banded(int x0, int x1){+ int x0_ = Marshaling<int,int>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);++ return new CasADi::CRSSparsity( CasADi::sp_banded(x0_, x1_) );+}+++// ================== function "CasADi::sp_rowcol" ===============+// cppName: "CasADi::sp_rowcol"+// cWrapperName: "CasADi__sp_rowcol"+// protoArgs: "(std::vector<int > * x0, std::vector<int > * x1, int x2, int x3)"+// params: [ConstRef (Vec (NonVec CInt)),ConstRef (Vec (NonVec CInt)),Val (NonVec CInt),Val (NonVec CInt)]+// args: "(x0_, x1_, x2_, x3_)"+// cWrapperRetType: "CasADi::CRSSparsity*"+// proto: "CasADi::CRSSparsity* CasADi__sp_rowcol(std::vector<int > * x0, std::vector<int > * x1, int x2, int x3)"+// call: "CasADi::sp_rowcol(x0_, x1_, x2_, x3_)"+extern "C"+ CasADi::CRSSparsity* CasADi__sp_rowcol(std::vector<int > * x0, std::vector<int > * x1, int x2, int x3);+CasADi::CRSSparsity* CasADi__sp_rowcol(std::vector<int > * x0, std::vector<int > * x1, int x2, int x3){+ std::vector<int > x0_ = Marshaling<std::vector<int >,std::vector<int > *>::marshal(x0);+ std::vector<int > x1_ = Marshaling<std::vector<int >,std::vector<int > *>::marshal(x1);+ int x2_ = Marshaling<int,int>::marshal(x2);+ int x3_ = Marshaling<int,int>::marshal(x3);++ return new CasADi::CRSSparsity( CasADi::sp_rowcol(x0_, x1_, x2_, x3_) );+}+++// ================== function "CasADi::getNZDense" ===============+// cppName: "CasADi::getNZDense"+// cWrapperName: "CasADi__getNZDense"+// protoArgs: "(CasADi::CRSSparsity* x0)"+// params: [ConstRef (NonVec (CasadiClass CRSSparsity))]+// args: "(x0_)"+// cWrapperRetType: "std::vector<int >*"+// proto: "std::vector<int >* CasADi__getNZDense(CasADi::CRSSparsity* x0)"+// call: "CasADi::getNZDense(x0_)"+extern "C"+ std::vector<int >* CasADi__getNZDense(CasADi::CRSSparsity* x0);+std::vector<int >* CasADi__getNZDense(CasADi::CRSSparsity* x0){+ CasADi::CRSSparsity x0_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x0);++ return new std::vector<int >( CasADi::getNZDense(x0_) );+}+++// ================== function "CasADi::reshape''''''" ===============+// cppName: "CasADi::reshape''''''"+// cWrapperName: "CasADi__reshape_TIC_TIC_TIC_TIC_TIC_TIC"+// protoArgs: "(CasADi::CRSSparsity* x0, int x1, int x2)"+// params: [ConstRef (NonVec (CasadiClass CRSSparsity)),Val (NonVec CInt),Val (NonVec CInt)]+// args: "(x0_, x1_, x2_)"+// cWrapperRetType: "CasADi::CRSSparsity*"+// proto: "CasADi::CRSSparsity* CasADi__reshape_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::CRSSparsity* x0, int x1, int x2)"+// call: "CasADi::reshape(x0_, x1_, x2_)"+extern "C"+ CasADi::CRSSparsity* CasADi__reshape_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::CRSSparsity* x0, int x1, int x2);+CasADi::CRSSparsity* CasADi__reshape_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::CRSSparsity* x0, int x1, int x2){+ CasADi::CRSSparsity x0_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);+ int x2_ = Marshaling<int,int>::marshal(x2);++ return new CasADi::CRSSparsity( CasADi::reshape(x0_, x1_, x2_) );+}+++// ================== function "CasADi::vec'''" ===============+// cppName: "CasADi::vec'''"+// cWrapperName: "CasADi__vec_TIC_TIC_TIC"+// protoArgs: "(CasADi::CRSSparsity* x0)"+// params: [ConstRef (NonVec (CasadiClass CRSSparsity))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::CRSSparsity*"+// proto: "CasADi::CRSSparsity* CasADi__vec_TIC_TIC_TIC(CasADi::CRSSparsity* x0)"+// call: "CasADi::vec(x0_)"+extern "C"+ CasADi::CRSSparsity* CasADi__vec_TIC_TIC_TIC(CasADi::CRSSparsity* x0);+CasADi::CRSSparsity* CasADi__vec_TIC_TIC_TIC(CasADi::CRSSparsity* x0){+ CasADi::CRSSparsity x0_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x0);++ return new CasADi::CRSSparsity( CasADi::vec(x0_) );+}+++// ================== function "CasADi::trans'''" ===============+// cppName: "CasADi::trans'''"+// cWrapperName: "CasADi__trans_TIC_TIC_TIC"+// protoArgs: "(CasADi::CRSSparsity* x0)"+// params: [ConstRef (NonVec (CasadiClass CRSSparsity))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::CRSSparsity*"+// proto: "CasADi::CRSSparsity* CasADi__trans_TIC_TIC_TIC(CasADi::CRSSparsity* x0)"+// call: "CasADi::trans(x0_)"+extern "C"+ CasADi::CRSSparsity* CasADi__trans_TIC_TIC_TIC(CasADi::CRSSparsity* x0);+CasADi::CRSSparsity* CasADi__trans_TIC_TIC_TIC(CasADi::CRSSparsity* x0){+ CasADi::CRSSparsity x0_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x0);++ return new CasADi::CRSSparsity( CasADi::trans(x0_) );+}+++// ================== function "CasADi::lowerSparsity" ===============+// cppName: "CasADi::lowerSparsity"+// cWrapperName: "CasADi__lowerSparsity"+// protoArgs: "(CasADi::CRSSparsity* x0, bool* x1)"+// params: [ConstRef (NonVec (CasadiClass CRSSparsity)),Val (NonVec CBool)]+// args: "(x0_, x1_)"+// cWrapperRetType: "CasADi::CRSSparsity*"+// proto: "CasADi::CRSSparsity* CasADi__lowerSparsity(CasADi::CRSSparsity* x0, bool* x1)"+// call: "CasADi::lowerSparsity(x0_, x1_)"+extern "C"+ CasADi::CRSSparsity* CasADi__lowerSparsity(CasADi::CRSSparsity* x0, bool* x1);+CasADi::CRSSparsity* CasADi__lowerSparsity(CasADi::CRSSparsity* x0, bool* x1){+ CasADi::CRSSparsity x0_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x0);+ bool x1_ = Marshaling<bool,bool*>::marshal(x1);++ return new CasADi::CRSSparsity( CasADi::lowerSparsity(x0_, x1_) );+}+++// ================== function "CasADi::lowerSparsity'" ===============+// cppName: "CasADi::lowerSparsity'"+// cWrapperName: "CasADi__lowerSparsity_TIC"+// protoArgs: "(CasADi::CRSSparsity* x0)"+// params: [ConstRef (NonVec (CasadiClass CRSSparsity))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::CRSSparsity*"+// proto: "CasADi::CRSSparsity* CasADi__lowerSparsity_TIC(CasADi::CRSSparsity* x0)"+// call: "CasADi::lowerSparsity(x0_)"+extern "C"+ CasADi::CRSSparsity* CasADi__lowerSparsity_TIC(CasADi::CRSSparsity* x0);+CasADi::CRSSparsity* CasADi__lowerSparsity_TIC(CasADi::CRSSparsity* x0){+ CasADi::CRSSparsity x0_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x0);++ return new CasADi::CRSSparsity( CasADi::lowerSparsity(x0_) );+}+++// ================== function "CasADi::lowerNZ" ===============+// cppName: "CasADi::lowerNZ"+// cWrapperName: "CasADi__lowerNZ"+// protoArgs: "(CasADi::CRSSparsity* x0)"+// params: [ConstRef (NonVec (CasadiClass CRSSparsity))]+// args: "(x0_)"+// cWrapperRetType: "std::vector<int >*"+// proto: "std::vector<int >* CasADi__lowerNZ(CasADi::CRSSparsity* x0)"+// call: "CasADi::lowerNZ(x0_)"+extern "C"+ std::vector<int >* CasADi__lowerNZ(CasADi::CRSSparsity* x0);+std::vector<int >* CasADi__lowerNZ(CasADi::CRSSparsity* x0){+ CasADi::CRSSparsity x0_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x0);++ return new std::vector<int >( CasADi::lowerNZ(x0_) );+}+++// ================== function "CasADi::sp_triplet" ===============+// cppName: "CasADi::sp_triplet"+// cWrapperName: "CasADi__sp_triplet"+// protoArgs: "(int x0, int x1, std::vector<int > * x2, std::vector<int > * x3, std::vector<int >* x4, bool* x5)"+// params: [Val (NonVec CInt),Val (NonVec CInt),ConstRef (Vec (NonVec CInt)),ConstRef (Vec (NonVec CInt)),Ref (Vec (NonVec CInt)),Val (NonVec CBool)]+// args: "(x0_, x1_, x2_, x3_, x4_, x5_)"+// cWrapperRetType: "CasADi::CRSSparsity*"+// proto: "CasADi::CRSSparsity* CasADi__sp_triplet(int x0, int x1, std::vector<int > * x2, std::vector<int > * x3, std::vector<int >* x4, bool* x5)"+// call: "CasADi::sp_triplet(x0_, x1_, x2_, x3_, x4_, x5_)"+extern "C"+ CasADi::CRSSparsity* CasADi__sp_triplet(int x0, int x1, std::vector<int > * x2, std::vector<int > * x3, std::vector<int >* x4, bool* x5);+CasADi::CRSSparsity* CasADi__sp_triplet(int x0, int x1, std::vector<int > * x2, std::vector<int > * x3, std::vector<int >* x4, bool* x5){+ int x0_ = Marshaling<int,int>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);+ std::vector<int > x2_ = Marshaling<std::vector<int >,std::vector<int > *>::marshal(x2);+ std::vector<int > x3_ = Marshaling<std::vector<int >,std::vector<int > *>::marshal(x3);+ std::vector<int > x4_ = Marshaling<std::vector<int >,std::vector<int >*>::marshal(x4);+ bool x5_ = Marshaling<bool,bool*>::marshal(x5);++ return new CasADi::CRSSparsity( CasADi::sp_triplet(x0_, x1_, x2_, x3_, x4_, x5_) );+}+++// ================== function "CasADi::sp_triplet'" ===============+// cppName: "CasADi::sp_triplet'"+// cWrapperName: "CasADi__sp_triplet_TIC"+// protoArgs: "(int x0, int x1, std::vector<int > * x2, std::vector<int > * x3, std::vector<int >* x4)"+// params: [Val (NonVec CInt),Val (NonVec CInt),ConstRef (Vec (NonVec CInt)),ConstRef (Vec (NonVec CInt)),Ref (Vec (NonVec CInt))]+// args: "(x0_, x1_, x2_, x3_, x4_)"+// cWrapperRetType: "CasADi::CRSSparsity*"+// proto: "CasADi::CRSSparsity* CasADi__sp_triplet_TIC(int x0, int x1, std::vector<int > * x2, std::vector<int > * x3, std::vector<int >* x4)"+// call: "CasADi::sp_triplet(x0_, x1_, x2_, x3_, x4_)"+extern "C"+ CasADi::CRSSparsity* CasADi__sp_triplet_TIC(int x0, int x1, std::vector<int > * x2, std::vector<int > * x3, std::vector<int >* x4);+CasADi::CRSSparsity* CasADi__sp_triplet_TIC(int x0, int x1, std::vector<int > * x2, std::vector<int > * x3, std::vector<int >* x4){+ int x0_ = Marshaling<int,int>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);+ std::vector<int > x2_ = Marshaling<std::vector<int >,std::vector<int > *>::marshal(x2);+ std::vector<int > x3_ = Marshaling<std::vector<int >,std::vector<int > *>::marshal(x3);+ std::vector<int > x4_ = Marshaling<std::vector<int >,std::vector<int >*>::marshal(x4);++ return new CasADi::CRSSparsity( CasADi::sp_triplet(x0_, x1_, x2_, x3_, x4_) );+}+++// ================== function "CasADi::sp_triplet''" ===============+// cppName: "CasADi::sp_triplet''"+// cWrapperName: "CasADi__sp_triplet_TIC_TIC"+// protoArgs: "(int x0, int x1, std::vector<int > * x2, std::vector<int > * x3)"+// params: [Val (NonVec CInt),Val (NonVec CInt),ConstRef (Vec (NonVec CInt)),ConstRef (Vec (NonVec CInt))]+// args: "(x0_, x1_, x2_, x3_)"+// cWrapperRetType: "CasADi::CRSSparsity*"+// proto: "CasADi::CRSSparsity* CasADi__sp_triplet_TIC_TIC(int x0, int x1, std::vector<int > * x2, std::vector<int > * x3)"+// call: "CasADi::sp_triplet(x0_, x1_, x2_, x3_)"+extern "C"+ CasADi::CRSSparsity* CasADi__sp_triplet_TIC_TIC(int x0, int x1, std::vector<int > * x2, std::vector<int > * x3);+CasADi::CRSSparsity* CasADi__sp_triplet_TIC_TIC(int x0, int x1, std::vector<int > * x2, std::vector<int > * x3){+ int x0_ = Marshaling<int,int>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);+ std::vector<int > x2_ = Marshaling<std::vector<int >,std::vector<int > *>::marshal(x2);+ std::vector<int > x3_ = Marshaling<std::vector<int >,std::vector<int > *>::marshal(x3);++ return new CasADi::CRSSparsity( CasADi::sp_triplet(x0_, x1_, x2_, x3_) );+}+++// ================== function "CasADi::mul'''''''''" ===============+// cppName: "CasADi::mul'''''''''"+// cWrapperName: "CasADi__mul_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"+// protoArgs: "(CasADi::CRSSparsity* x0, CasADi::CRSSparsity* x1)"+// params: [ConstRef (NonVec (CasadiClass CRSSparsity)),ConstRef (NonVec (CasadiClass CRSSparsity))]+// args: "(x0_, x1_)"+// cWrapperRetType: "CasADi::CRSSparsity*"+// proto: "CasADi::CRSSparsity* CasADi__mul_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::CRSSparsity* x0, CasADi::CRSSparsity* x1)"+// call: "CasADi::mul(x0_, x1_)"+extern "C"+ CasADi::CRSSparsity* CasADi__mul_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::CRSSparsity* x0, CasADi::CRSSparsity* x1);+CasADi::CRSSparsity* CasADi__mul_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::CRSSparsity* x0, CasADi::CRSSparsity* x1){+ CasADi::CRSSparsity x0_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x0);+ CasADi::CRSSparsity x1_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x1);++ return new CasADi::CRSSparsity( CasADi::mul(x0_, x1_) );+}+++// ================== function "CasADi::vertcat'''" ===============+// cppName: "CasADi::vertcat'''"+// cWrapperName: "CasADi__vertcat_TIC_TIC_TIC"+// protoArgs: "(std::vector<CasADi::CRSSparsity* > * x0)"+// params: [ConstRef (Vec (NonVec (CasadiClass CRSSparsity)))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::CRSSparsity*"+// proto: "CasADi::CRSSparsity* CasADi__vertcat_TIC_TIC_TIC(std::vector<CasADi::CRSSparsity* > * x0)"+// call: "CasADi::vertcat(x0_)"+extern "C"+ CasADi::CRSSparsity* CasADi__vertcat_TIC_TIC_TIC(std::vector<CasADi::CRSSparsity* > * x0);+CasADi::CRSSparsity* CasADi__vertcat_TIC_TIC_TIC(std::vector<CasADi::CRSSparsity* > * x0){+ std::vector<CasADi::CRSSparsity > x0_ = Marshaling<std::vector<CasADi::CRSSparsity >,std::vector<CasADi::CRSSparsity* > *>::marshal(x0);++ return new CasADi::CRSSparsity( CasADi::vertcat(x0_) );+}+++// ================== function "CasADi::horzcat'''" ===============+// cppName: "CasADi::horzcat'''"+// cWrapperName: "CasADi__horzcat_TIC_TIC_TIC"+// protoArgs: "(std::vector<CasADi::CRSSparsity* > * x0)"+// params: [ConstRef (Vec (NonVec (CasadiClass CRSSparsity)))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::CRSSparsity*"+// proto: "CasADi::CRSSparsity* CasADi__horzcat_TIC_TIC_TIC(std::vector<CasADi::CRSSparsity* > * x0)"+// call: "CasADi::horzcat(x0_)"+extern "C"+ CasADi::CRSSparsity* CasADi__horzcat_TIC_TIC_TIC(std::vector<CasADi::CRSSparsity* > * x0);+CasADi::CRSSparsity* CasADi__horzcat_TIC_TIC_TIC(std::vector<CasADi::CRSSparsity* > * x0){+ std::vector<CasADi::CRSSparsity > x0_ = Marshaling<std::vector<CasADi::CRSSparsity >,std::vector<CasADi::CRSSparsity* > *>::marshal(x0);++ return new CasADi::CRSSparsity( CasADi::horzcat(x0_) );+}+++// ================== function "CasADi::blkdiag'''" ===============+// cppName: "CasADi::blkdiag'''"+// cWrapperName: "CasADi__blkdiag_TIC_TIC_TIC"+// protoArgs: "(std::vector<CasADi::CRSSparsity* > * x0)"+// params: [ConstRef (Vec (NonVec (CasadiClass CRSSparsity)))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::CRSSparsity*"+// proto: "CasADi::CRSSparsity* CasADi__blkdiag_TIC_TIC_TIC(std::vector<CasADi::CRSSparsity* > * x0)"+// call: "CasADi::blkdiag(x0_)"+extern "C"+ CasADi::CRSSparsity* CasADi__blkdiag_TIC_TIC_TIC(std::vector<CasADi::CRSSparsity* > * x0);+CasADi::CRSSparsity* CasADi__blkdiag_TIC_TIC_TIC(std::vector<CasADi::CRSSparsity* > * x0){+ std::vector<CasADi::CRSSparsity > x0_ = Marshaling<std::vector<CasADi::CRSSparsity >,std::vector<CasADi::CRSSparsity* > *>::marshal(x0);++ return new CasADi::CRSSparsity( CasADi::blkdiag(x0_) );+}+++// ================== function "CasADi::sp_compress" ===============+// cppName: "CasADi::sp_compress"+// cWrapperName: "CasADi__sp_compress"+// protoArgs: "(CasADi::CRSSparsity* x0)"+// params: [ConstRef (NonVec (CasadiClass CRSSparsity))]+// args: "(x0_)"+// cWrapperRetType: "std::vector<int >*"+// proto: "std::vector<int >* CasADi__sp_compress(CasADi::CRSSparsity* x0)"+// call: "CasADi::sp_compress(x0_)"+extern "C"+ std::vector<int >* CasADi__sp_compress(CasADi::CRSSparsity* x0);+std::vector<int >* CasADi__sp_compress(CasADi::CRSSparsity* x0){+ CasADi::CRSSparsity x0_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x0);++ return new std::vector<int >( CasADi::sp_compress(x0_) );+}+++// ================== function "CasADi::sp_compress'" ===============+// cppName: "CasADi::sp_compress'"+// cWrapperName: "CasADi__sp_compress_TIC"+// protoArgs: "(std::vector<int > * x0)"+// params: [ConstRef (Vec (NonVec CInt))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::CRSSparsity*"+// proto: "CasADi::CRSSparsity* CasADi__sp_compress_TIC(std::vector<int > * x0)"+// call: "CasADi::sp_compress(x0_)"+extern "C"+ CasADi::CRSSparsity* CasADi__sp_compress_TIC(std::vector<int > * x0);+CasADi::CRSSparsity* CasADi__sp_compress_TIC(std::vector<int > * x0){+ std::vector<int > x0_ = Marshaling<std::vector<int >,std::vector<int > *>::marshal(x0);++ return new CasADi::CRSSparsity( CasADi::sp_compress(x0_) );+}+++// ================== function "CasADi::rank" ===============+// cppName: "CasADi::rank"+// cWrapperName: "CasADi__rank"+// protoArgs: "(CasADi::CRSSparsity* x0)"+// params: [ConstRef (NonVec (CasadiClass CRSSparsity))]+// args: "(x0_)"+// cWrapperRetType: "int"+// proto: "int CasADi__rank(CasADi::CRSSparsity* x0)"+// call: "CasADi::rank(x0_)"+extern "C"+ int CasADi__rank(CasADi::CRSSparsity* x0);+int CasADi__rank(CasADi::CRSSparsity* x0){+ CasADi::CRSSparsity x0_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x0);++ return CasADi::rank(x0_);+}+++// ================== function "CasADi::isSingular" ===============+// cppName: "CasADi::isSingular"+// cWrapperName: "CasADi__isSingular"+// protoArgs: "(CasADi::CRSSparsity* x0)"+// params: [ConstRef (NonVec (CasadiClass CRSSparsity))]+// args: "(x0_)"+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__isSingular(CasADi::CRSSparsity* x0)"+// call: "CasADi::isSingular(x0_)"+extern "C"+ bool* CasADi__isSingular(CasADi::CRSSparsity* x0);+bool* CasADi__isSingular(CasADi::CRSSparsity* x0){+ CasADi::CRSSparsity x0_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x0);++ return new bool( CasADi::isSingular(x0_) );+}+++// ================== function "CasADi::ssym" ===============+// cppName: "CasADi::ssym"+// cWrapperName: "CasADi__ssym"+// protoArgs: "(std::string* x0, int x1, int x2)"+// params: [ConstRef (NonVec StdString),Val (NonVec CInt),Val (NonVec CInt)]+// args: "(x0_, x1_, x2_)"+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__ssym(std::string* x0, int x1, int x2)"+// call: "CasADi::ssym(x0_, x1_, x2_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__ssym(std::string* x0, int x1, int x2);+CasADi::Matrix< CasADi::SX >* CasADi__ssym(std::string* x0, int x1, int x2){+ std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);+ int x2_ = Marshaling<int,int>::marshal(x2);++ return new CasADi::Matrix< CasADi::SX >( CasADi::ssym(x0_, x1_, x2_) );+}+++// ================== function "CasADi::ssym'" ===============+// cppName: "CasADi::ssym'"+// cWrapperName: "CasADi__ssym_TIC"+// protoArgs: "(std::string* x0, int x1)"+// params: [ConstRef (NonVec StdString),Val (NonVec CInt)]+// args: "(x0_, x1_)"+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__ssym_TIC(std::string* x0, int x1)"+// call: "CasADi::ssym(x0_, x1_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__ssym_TIC(std::string* x0, int x1);+CasADi::Matrix< CasADi::SX >* CasADi__ssym_TIC(std::string* x0, int x1){+ std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);++ return new CasADi::Matrix< CasADi::SX >( CasADi::ssym(x0_, x1_) );+}+++// ================== function "CasADi::ssym''" ===============+// cppName: "CasADi::ssym''"+// cWrapperName: "CasADi__ssym_TIC_TIC"+// protoArgs: "(std::string* x0)"+// params: [ConstRef (NonVec StdString)]+// args: "(x0_)"+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__ssym_TIC_TIC(std::string* x0)"+// call: "CasADi::ssym(x0_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__ssym_TIC_TIC(std::string* x0);+CasADi::Matrix< CasADi::SX >* CasADi__ssym_TIC_TIC(std::string* x0){+ std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);++ return new CasADi::Matrix< CasADi::SX >( CasADi::ssym(x0_) );+}+++// ================== function "CasADi::ssym'''" ===============+// cppName: "CasADi::ssym'''"+// cWrapperName: "CasADi__ssym_TIC_TIC_TIC"+// protoArgs: "(std::string* x0, CasADi::CRSSparsity* x1, int x2)"+// params: [ConstRef (NonVec StdString),ConstRef (NonVec (CasadiClass CRSSparsity)),Val (NonVec CInt)]+// args: "(x0_, x1_, x2_)"+// cWrapperRetType: "std::vector<CasADi::Matrix< CasADi::SX > >*"+// proto: "std::vector<CasADi::Matrix< CasADi::SX > >* CasADi__ssym_TIC_TIC_TIC(std::string* x0, CasADi::CRSSparsity* x1, int x2)"+// call: "CasADi::ssym(x0_, x1_, x2_)"+extern "C"+ std::vector<CasADi::Matrix< CasADi::SX > >* CasADi__ssym_TIC_TIC_TIC(std::string* x0, CasADi::CRSSparsity* x1, int x2);+std::vector<CasADi::Matrix< CasADi::SX > >* CasADi__ssym_TIC_TIC_TIC(std::string* x0, CasADi::CRSSparsity* x1, int x2){+ std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);+ CasADi::CRSSparsity x1_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x1);+ int x2_ = Marshaling<int,int>::marshal(x2);++ return new std::vector<CasADi::Matrix< CasADi::SX > >( CasADi::ssym(x0_, x1_, x2_) );+}+++// ================== function "CasADi::ssym''''" ===============+// cppName: "CasADi::ssym''''"+// cWrapperName: "CasADi__ssym_TIC_TIC_TIC_TIC"+// protoArgs: "(std::string* x0, int x1, int x2, int x3)"+// params: [ConstRef (NonVec StdString),Val (NonVec CInt),Val (NonVec CInt),Val (NonVec CInt)]+// args: "(x0_, x1_, x2_, x3_)"+// cWrapperRetType: "std::vector<CasADi::Matrix< CasADi::SX > >*"+// proto: "std::vector<CasADi::Matrix< CasADi::SX > >* CasADi__ssym_TIC_TIC_TIC_TIC(std::string* x0, int x1, int x2, int x3)"+// call: "CasADi::ssym(x0_, x1_, x2_, x3_)"+extern "C"+ std::vector<CasADi::Matrix< CasADi::SX > >* CasADi__ssym_TIC_TIC_TIC_TIC(std::string* x0, int x1, int x2, int x3);+std::vector<CasADi::Matrix< CasADi::SX > >* CasADi__ssym_TIC_TIC_TIC_TIC(std::string* x0, int x1, int x2, int x3){+ std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);+ int x2_ = Marshaling<int,int>::marshal(x2);+ int x3_ = Marshaling<int,int>::marshal(x3);++ return new std::vector<CasADi::Matrix< CasADi::SX > >( CasADi::ssym(x0_, x1_, x2_, x3_) );+}+++// ================== function "CasADi::ssym'''''" ===============+// cppName: "CasADi::ssym'''''"+// cWrapperName: "CasADi__ssym_TIC_TIC_TIC_TIC_TIC"+// protoArgs: "(std::string* x0, CasADi::CRSSparsity* x1, int x2, int x3)"+// params: [ConstRef (NonVec StdString),ConstRef (NonVec (CasadiClass CRSSparsity)),Val (NonVec CInt),Val (NonVec CInt)]+// args: "(x0_, x1_, x2_, x3_)"+// cWrapperRetType: "std::vector<std::vector<CasADi::Matrix< CasADi::SX > > >*"+// proto: "std::vector<std::vector<CasADi::Matrix< CasADi::SX > > >* CasADi__ssym_TIC_TIC_TIC_TIC_TIC(std::string* x0, CasADi::CRSSparsity* x1, int x2, int x3)"+// call: "CasADi::ssym(x0_, x1_, x2_, x3_)"+extern "C"+ std::vector<std::vector<CasADi::Matrix< CasADi::SX > > >* CasADi__ssym_TIC_TIC_TIC_TIC_TIC(std::string* x0, CasADi::CRSSparsity* x1, int x2, int x3);+std::vector<std::vector<CasADi::Matrix< CasADi::SX > > >* CasADi__ssym_TIC_TIC_TIC_TIC_TIC(std::string* x0, CasADi::CRSSparsity* x1, int x2, int x3){+ std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);+ CasADi::CRSSparsity x1_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x1);+ int x2_ = Marshaling<int,int>::marshal(x2);+ int x3_ = Marshaling<int,int>::marshal(x3);++ return new std::vector<std::vector<CasADi::Matrix< CasADi::SX > > >( CasADi::ssym(x0_, x1_, x2_, x3_) );+}+++// ================== function "CasADi::ssym''''''" ===============+// cppName: "CasADi::ssym''''''"+// cWrapperName: "CasADi__ssym_TIC_TIC_TIC_TIC_TIC_TIC"+// protoArgs: "(std::string* x0, int x1, int x2, int x3, int x4)"+// params: [ConstRef (NonVec StdString),Val (NonVec CInt),Val (NonVec CInt),Val (NonVec CInt),Val (NonVec CInt)]+// args: "(x0_, x1_, x2_, x3_, x4_)"+// cWrapperRetType: "std::vector<std::vector<CasADi::Matrix< CasADi::SX > > >*"+// proto: "std::vector<std::vector<CasADi::Matrix< CasADi::SX > > >* CasADi__ssym_TIC_TIC_TIC_TIC_TIC_TIC(std::string* x0, int x1, int x2, int x3, int x4)"+// call: "CasADi::ssym(x0_, x1_, x2_, x3_, x4_)"+extern "C"+ std::vector<std::vector<CasADi::Matrix< CasADi::SX > > >* CasADi__ssym_TIC_TIC_TIC_TIC_TIC_TIC(std::string* x0, int x1, int x2, int x3, int x4);+std::vector<std::vector<CasADi::Matrix< CasADi::SX > > >* CasADi__ssym_TIC_TIC_TIC_TIC_TIC_TIC(std::string* x0, int x1, int x2, int x3, int x4){+ std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);+ int x2_ = Marshaling<int,int>::marshal(x2);+ int x3_ = Marshaling<int,int>::marshal(x3);+ int x4_ = Marshaling<int,int>::marshal(x4);++ return new std::vector<std::vector<CasADi::Matrix< CasADi::SX > > >( CasADi::ssym(x0_, x1_, x2_, x3_, x4_) );+}+++// ================== function "CasADi::ssym'''''''" ===============+// cppName: "CasADi::ssym'''''''"+// cWrapperName: "CasADi__ssym_TIC_TIC_TIC_TIC_TIC_TIC_TIC"+// protoArgs: "(std::string* x0, CasADi::CRSSparsity* x1)"+// params: [ConstRef (NonVec StdString),ConstRef (NonVec (CasadiClass CRSSparsity))]+// args: "(x0_, x1_)"+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__ssym_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::string* x0, CasADi::CRSSparsity* x1)"+// call: "CasADi::ssym(x0_, x1_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__ssym_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::string* x0, CasADi::CRSSparsity* x1);+CasADi::Matrix< CasADi::SX >* CasADi__ssym_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::string* x0, CasADi::CRSSparsity* x1){+ std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);+ CasADi::CRSSparsity x1_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x1);++ return new CasADi::Matrix< CasADi::SX >( CasADi::ssym(x0_, x1_) );+}+++// ================== function "CasADi::ssym''''''''" ===============+// cppName: "CasADi::ssym''''''''"+// cWrapperName: "CasADi__ssym_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"+// protoArgs: "(CasADi::Matrix< double >* x0)"+// params: [ConstRef (NonVec (CasadiClass DMatrix))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__ssym_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* x0)"+// call: "CasADi::ssym(x0_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__ssym_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* x0);+CasADi::Matrix< CasADi::SX >* CasADi__ssym_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* x0){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);++ return new CasADi::Matrix< CasADi::SX >( CasADi::ssym(x0_) );+}+++// ================== function "CasADi::expand" ===============+// cppName: "CasADi::expand"+// cWrapperName: "CasADi__expand"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix)),Ref (NonVec (CasadiClass SXMatrix)),Ref (NonVec (CasadiClass SXMatrix))]+// args: "(x0_, x1_, x2_)"+// cWrapperRetType: "void"+// proto: "void CasADi__expand(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2)"+// call: "CasADi::expand(x0_, x1_, x2_)"+extern "C"+ void CasADi__expand(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2);+void CasADi__expand(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);+ CasADi::Matrix< CasADi::SX > x1_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x1);+ CasADi::Matrix< CasADi::SX > x2_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x2);++ return CasADi::expand(x0_, x1_, x2_);+}+++// ================== function "CasADi::simplify" ===============+// cppName: "CasADi::simplify"+// cWrapperName: "CasADi__simplify"+// protoArgs: "(CasADi::SX* x0)"+// params: [Ref (NonVec (CasadiClass SX))]+// args: "(x0_)"+// cWrapperRetType: "void"+// proto: "void CasADi__simplify(CasADi::SX* x0)"+// call: "CasADi::simplify(x0_)"+extern "C"+ void CasADi__simplify(CasADi::SX* x0);+void CasADi__simplify(CasADi::SX* x0){+ CasADi::SX x0_ = Marshaling<CasADi::SX,CasADi::SX*>::marshal(x0);++ return CasADi::simplify(x0_);+}+++// ================== function "CasADi::pw_const" ===============+// cppName: "CasADi::pw_const"+// cWrapperName: "CasADi__pw_const"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass SXMatrix))]+// args: "(x0_, x1_, x2_)"+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__pw_const(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2)"+// call: "CasADi::pw_const(x0_, x1_, x2_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__pw_const(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2);+CasADi::Matrix< CasADi::SX >* CasADi__pw_const(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);+ CasADi::Matrix< CasADi::SX > x1_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x1);+ CasADi::Matrix< CasADi::SX > x2_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x2);++ return new CasADi::Matrix< CasADi::SX >( CasADi::pw_const(x0_, x1_, x2_) );+}+++// ================== function "CasADi::pw_lin" ===============+// cppName: "CasADi::pw_lin"+// cWrapperName: "CasADi__pw_lin"+// protoArgs: "(CasADi::SX* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2)"+// params: [ConstRef (NonVec (CasadiClass SX)),ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass SXMatrix))]+// args: "(x0_, x1_, x2_)"+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__pw_lin(CasADi::SX* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2)"+// call: "CasADi::pw_lin(x0_, x1_, x2_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__pw_lin(CasADi::SX* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2);+CasADi::Matrix< CasADi::SX >* CasADi__pw_lin(CasADi::SX* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2){+ CasADi::SX x0_ = Marshaling<CasADi::SX,CasADi::SX*>::marshal(x0);+ CasADi::Matrix< CasADi::SX > x1_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x1);+ CasADi::Matrix< CasADi::SX > x2_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x2);++ return new CasADi::Matrix< CasADi::SX >( CasADi::pw_lin(x0_, x1_, x2_) );+}+++// ================== function "CasADi::if_else" ===============+// cppName: "CasADi::if_else"+// cWrapperName: "CasADi__if_else"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass SXMatrix))]+// args: "(x0_, x1_, x2_)"+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__if_else(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2)"+// call: "CasADi::if_else(x0_, x1_, x2_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__if_else(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2);+CasADi::Matrix< CasADi::SX >* CasADi__if_else(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);+ CasADi::Matrix< CasADi::SX > x1_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x1);+ CasADi::Matrix< CasADi::SX > x2_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x2);++ return new CasADi::Matrix< CasADi::SX >( CasADi::if_else(x0_, x1_, x2_) );+}+++// ================== function "CasADi::heaviside" ===============+// cppName: "CasADi::heaviside"+// cWrapperName: "CasADi__heaviside"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__heaviside(CasADi::Matrix< CasADi::SX >* x0)"+// call: "CasADi::heaviside(x0_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__heaviside(CasADi::Matrix< CasADi::SX >* x0);+CasADi::Matrix< CasADi::SX >* CasADi__heaviside(CasADi::Matrix< CasADi::SX >* x0){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);++ return new CasADi::Matrix< CasADi::SX >( CasADi::heaviside(x0_) );+}+++// ================== function "CasADi::rectangle" ===============+// cppName: "CasADi::rectangle"+// cWrapperName: "CasADi__rectangle"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__rectangle(CasADi::Matrix< CasADi::SX >* x0)"+// call: "CasADi::rectangle(x0_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__rectangle(CasADi::Matrix< CasADi::SX >* x0);+CasADi::Matrix< CasADi::SX >* CasADi__rectangle(CasADi::Matrix< CasADi::SX >* x0){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);++ return new CasADi::Matrix< CasADi::SX >( CasADi::rectangle(x0_) );+}+++// ================== function "CasADi::triangle" ===============+// cppName: "CasADi::triangle"+// cWrapperName: "CasADi__triangle"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__triangle(CasADi::Matrix< CasADi::SX >* x0)"+// call: "CasADi::triangle(x0_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__triangle(CasADi::Matrix< CasADi::SX >* x0);+CasADi::Matrix< CasADi::SX >* CasADi__triangle(CasADi::Matrix< CasADi::SX >* x0){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);++ return new CasADi::Matrix< CasADi::SX >( CasADi::triangle(x0_) );+}+++// ================== function "CasADi::ramp" ===============+// cppName: "CasADi::ramp"+// cWrapperName: "CasADi__ramp"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__ramp(CasADi::Matrix< CasADi::SX >* x0)"+// call: "CasADi::ramp(x0_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__ramp(CasADi::Matrix< CasADi::SX >* x0);+CasADi::Matrix< CasADi::SX >* CasADi__ramp(CasADi::Matrix< CasADi::SX >* x0){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);++ return new CasADi::Matrix< CasADi::SX >( CasADi::ramp(x0_) );+}+++// ================== function "CasADi::gauss_quadrature" ===============+// cppName: "CasADi::gauss_quadrature"+// cWrapperName: "CasADi__gauss_quadrature"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2, CasADi::Matrix< CasADi::SX >* x3, int x4, CasADi::Matrix< CasADi::SX >* x5)"+// params: [Val (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass SXMatrix)),Val (NonVec CInt),ConstRef (NonVec (CasadiClass SXMatrix))]+// args: "(x0_, x1_, x2_, x3_, x4_, x5_)"+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__gauss_quadrature(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2, CasADi::Matrix< CasADi::SX >* x3, int x4, CasADi::Matrix< CasADi::SX >* x5)"+// call: "CasADi::gauss_quadrature(x0_, x1_, x2_, x3_, x4_, x5_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__gauss_quadrature(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2, CasADi::Matrix< CasADi::SX >* x3, int x4, CasADi::Matrix< CasADi::SX >* x5);+CasADi::Matrix< CasADi::SX >* CasADi__gauss_quadrature(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2, CasADi::Matrix< CasADi::SX >* x3, int x4, CasADi::Matrix< CasADi::SX >* x5){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);+ CasADi::Matrix< CasADi::SX > x1_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x1);+ CasADi::Matrix< CasADi::SX > x2_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x2);+ CasADi::Matrix< CasADi::SX > x3_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x3);+ int x4_ = Marshaling<int,int>::marshal(x4);+ CasADi::Matrix< CasADi::SX > x5_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x5);++ return new CasADi::Matrix< CasADi::SX >( CasADi::gauss_quadrature(x0_, x1_, x2_, x3_, x4_, x5_) );+}+++// ================== function "CasADi::gauss_quadrature'" ===============+// cppName: "CasADi::gauss_quadrature'"+// cWrapperName: "CasADi__gauss_quadrature_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2, CasADi::Matrix< CasADi::SX >* x3, int x4)"+// params: [Val (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass SXMatrix)),Val (NonVec CInt)]+// args: "(x0_, x1_, x2_, x3_, x4_)"+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__gauss_quadrature_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2, CasADi::Matrix< CasADi::SX >* x3, int x4)"+// call: "CasADi::gauss_quadrature(x0_, x1_, x2_, x3_, x4_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__gauss_quadrature_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2, CasADi::Matrix< CasADi::SX >* x3, int x4);+CasADi::Matrix< CasADi::SX >* CasADi__gauss_quadrature_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2, CasADi::Matrix< CasADi::SX >* x3, int x4){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);+ CasADi::Matrix< CasADi::SX > x1_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x1);+ CasADi::Matrix< CasADi::SX > x2_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x2);+ CasADi::Matrix< CasADi::SX > x3_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x3);+ int x4_ = Marshaling<int,int>::marshal(x4);++ return new CasADi::Matrix< CasADi::SX >( CasADi::gauss_quadrature(x0_, x1_, x2_, x3_, x4_) );+}+++// ================== function "CasADi::gauss_quadrature''" ===============+// cppName: "CasADi::gauss_quadrature''"+// cWrapperName: "CasADi__gauss_quadrature_TIC_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2, CasADi::Matrix< CasADi::SX >* x3)"+// params: [Val (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass SXMatrix))]+// args: "(x0_, x1_, x2_, x3_)"+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__gauss_quadrature_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2, CasADi::Matrix< CasADi::SX >* x3)"+// call: "CasADi::gauss_quadrature(x0_, x1_, x2_, x3_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__gauss_quadrature_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2, CasADi::Matrix< CasADi::SX >* x3);+CasADi::Matrix< CasADi::SX >* CasADi__gauss_quadrature_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2, CasADi::Matrix< CasADi::SX >* x3){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);+ CasADi::Matrix< CasADi::SX > x1_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x1);+ CasADi::Matrix< CasADi::SX > x2_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x2);+ CasADi::Matrix< CasADi::SX > x3_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x3);++ return new CasADi::Matrix< CasADi::SX >( CasADi::gauss_quadrature(x0_, x1_, x2_, x3_) );+}+++// ================== function "CasADi::simplify'" ===============+// cppName: "CasADi::simplify'"+// cWrapperName: "CasADi__simplify_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"+// params: [Ref (NonVec (CasadiClass SXMatrix))]+// args: "(x0_)"+// cWrapperRetType: "void"+// proto: "void CasADi__simplify_TIC(CasADi::Matrix< CasADi::SX >* x0)"+// call: "CasADi::simplify(x0_)"+extern "C"+ void CasADi__simplify_TIC(CasADi::Matrix< CasADi::SX >* x0);+void CasADi__simplify_TIC(CasADi::Matrix< CasADi::SX >* x0){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);++ return CasADi::simplify(x0_);+}+++// ================== function "CasADi::compress" ===============+// cppName: "CasADi::compress"+// cWrapperName: "CasADi__compress"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, int x1)"+// params: [Ref (NonVec (CasadiClass SXMatrix)),Val (NonVec CInt)]+// args: "(x0_, x1_)"+// cWrapperRetType: "void"+// proto: "void CasADi__compress(CasADi::Matrix< CasADi::SX >* x0, int x1)"+// call: "CasADi::compress(x0_, x1_)"+extern "C"+ void CasADi__compress(CasADi::Matrix< CasADi::SX >* x0, int x1);+void CasADi__compress(CasADi::Matrix< CasADi::SX >* x0, int x1){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);++ return CasADi::compress(x0_, x1_);+}+++// ================== function "CasADi::compress'" ===============+// cppName: "CasADi::compress'"+// cWrapperName: "CasADi__compress_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"+// params: [Ref (NonVec (CasadiClass SXMatrix))]+// args: "(x0_)"+// cWrapperRetType: "void"+// proto: "void CasADi__compress_TIC(CasADi::Matrix< CasADi::SX >* x0)"+// call: "CasADi::compress(x0_)"+extern "C"+ void CasADi__compress_TIC(CasADi::Matrix< CasADi::SX >* x0);+void CasADi__compress_TIC(CasADi::Matrix< CasADi::SX >* x0){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);++ return CasADi::compress(x0_);+}+++// ================== function "CasADi::substitute" ===============+// cppName: "CasADi::substitute"+// cWrapperName: "CasADi__substitute"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass SXMatrix))]+// args: "(x0_, x1_, x2_)"+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__substitute(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2)"+// call: "CasADi::substitute(x0_, x1_, x2_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__substitute(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2);+CasADi::Matrix< CasADi::SX >* CasADi__substitute(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);+ CasADi::Matrix< CasADi::SX > x1_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x1);+ CasADi::Matrix< CasADi::SX > x2_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x2);++ return new CasADi::Matrix< CasADi::SX >( CasADi::substitute(x0_, x1_, x2_) );+}+++// ================== function "CasADi::substitute'" ===============+// cppName: "CasADi::substitute'"+// cWrapperName: "CasADi__substitute_TIC"+// protoArgs: "(std::vector<CasADi::Matrix< CasADi::SX >* > * x0, std::vector<CasADi::Matrix< CasADi::SX >* > * x1, std::vector<CasADi::Matrix< CasADi::SX >* > * x2)"+// params: [ConstRef (Vec (NonVec (CasadiClass SXMatrix))),ConstRef (Vec (NonVec (CasadiClass SXMatrix))),ConstRef (Vec (NonVec (CasadiClass SXMatrix)))]+// args: "(x0_, x1_, x2_)"+// cWrapperRetType: "std::vector<CasADi::Matrix< CasADi::SX > >*"+// proto: "std::vector<CasADi::Matrix< CasADi::SX > >* CasADi__substitute_TIC(std::vector<CasADi::Matrix< CasADi::SX >* > * x0, std::vector<CasADi::Matrix< CasADi::SX >* > * x1, std::vector<CasADi::Matrix< CasADi::SX >* > * x2)"+// call: "CasADi::substitute(x0_, x1_, x2_)"+extern "C"+ std::vector<CasADi::Matrix< CasADi::SX > >* CasADi__substitute_TIC(std::vector<CasADi::Matrix< CasADi::SX >* > * x0, std::vector<CasADi::Matrix< CasADi::SX >* > * x1, std::vector<CasADi::Matrix< CasADi::SX >* > * x2);+std::vector<CasADi::Matrix< CasADi::SX > >* CasADi__substitute_TIC(std::vector<CasADi::Matrix< CasADi::SX >* > * x0, std::vector<CasADi::Matrix< CasADi::SX >* > * x1, std::vector<CasADi::Matrix< CasADi::SX >* > * x2){+ std::vector<CasADi::Matrix< CasADi::SX > > x0_ = Marshaling<std::vector<CasADi::Matrix< CasADi::SX > >,std::vector<CasADi::Matrix< CasADi::SX >* > *>::marshal(x0);+ std::vector<CasADi::Matrix< CasADi::SX > > x1_ = Marshaling<std::vector<CasADi::Matrix< CasADi::SX > >,std::vector<CasADi::Matrix< CasADi::SX >* > *>::marshal(x1);+ std::vector<CasADi::Matrix< CasADi::SX > > x2_ = Marshaling<std::vector<CasADi::Matrix< CasADi::SX > >,std::vector<CasADi::Matrix< CasADi::SX >* > *>::marshal(x2);++ return new std::vector<CasADi::Matrix< CasADi::SX > >( CasADi::substitute(x0_, x1_, x2_) );+}+++// ================== function "CasADi::substituteInPlace" ===============+// cppName: "CasADi::substituteInPlace"+// cWrapperName: "CasADi__substituteInPlace"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, bool* x2)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix)),Ref (NonVec (CasadiClass SXMatrix)),Val (NonVec CBool)]+// args: "(x0_, x1_, x2_)"+// cWrapperRetType: "void"+// proto: "void CasADi__substituteInPlace(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, bool* x2)"+// call: "CasADi::substituteInPlace(x0_, x1_, x2_)"+extern "C"+ void CasADi__substituteInPlace(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, bool* x2);+void CasADi__substituteInPlace(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, bool* x2){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);+ CasADi::Matrix< CasADi::SX > x1_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x1);+ bool x2_ = Marshaling<bool,bool*>::marshal(x2);++ return CasADi::substituteInPlace(x0_, x1_, x2_);+}+++// ================== function "CasADi::substituteInPlace'" ===============+// cppName: "CasADi::substituteInPlace'"+// cWrapperName: "CasADi__substituteInPlace_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix)),Ref (NonVec (CasadiClass SXMatrix))]+// args: "(x0_, x1_)"+// cWrapperRetType: "void"+// proto: "void CasADi__substituteInPlace_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1)"+// call: "CasADi::substituteInPlace(x0_, x1_)"+extern "C"+ void CasADi__substituteInPlace_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1);+void CasADi__substituteInPlace_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);+ CasADi::Matrix< CasADi::SX > x1_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x1);++ return CasADi::substituteInPlace(x0_, x1_);+}+++// ================== function "CasADi::substituteInPlace''" ===============+// cppName: "CasADi::substituteInPlace''"+// cWrapperName: "CasADi__substituteInPlace_TIC_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, std::vector<CasADi::Matrix< CasADi::SX >* >* x2, bool* x3)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix)),Ref (NonVec (CasadiClass SXMatrix)),Ref (Vec (NonVec (CasadiClass SXMatrix))),Val (NonVec CBool)]+// args: "(x0_, x1_, x2_, x3_)"+// cWrapperRetType: "void"+// proto: "void CasADi__substituteInPlace_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, std::vector<CasADi::Matrix< CasADi::SX >* >* x2, bool* x3)"+// call: "CasADi::substituteInPlace(x0_, x1_, x2_, x3_)"+extern "C"+ void CasADi__substituteInPlace_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, std::vector<CasADi::Matrix< CasADi::SX >* >* x2, bool* x3);+void CasADi__substituteInPlace_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, std::vector<CasADi::Matrix< CasADi::SX >* >* x2, bool* x3){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);+ CasADi::Matrix< CasADi::SX > x1_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x1);+ std::vector<CasADi::Matrix< CasADi::SX > > x2_ = Marshaling<std::vector<CasADi::Matrix< CasADi::SX > >,std::vector<CasADi::Matrix< CasADi::SX >* >*>::marshal(x2);+ bool x3_ = Marshaling<bool,bool*>::marshal(x3);++ return CasADi::substituteInPlace(x0_, x1_, x2_, x3_);+}+++// ================== function "CasADi::substituteInPlace'''" ===============+// cppName: "CasADi::substituteInPlace'''"+// cWrapperName: "CasADi__substituteInPlace_TIC_TIC_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, std::vector<CasADi::Matrix< CasADi::SX >* >* x2)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix)),Ref (NonVec (CasadiClass SXMatrix)),Ref (Vec (NonVec (CasadiClass SXMatrix)))]+// args: "(x0_, x1_, x2_)"+// cWrapperRetType: "void"+// proto: "void CasADi__substituteInPlace_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, std::vector<CasADi::Matrix< CasADi::SX >* >* x2)"+// call: "CasADi::substituteInPlace(x0_, x1_, x2_)"+extern "C"+ void CasADi__substituteInPlace_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, std::vector<CasADi::Matrix< CasADi::SX >* >* x2);+void CasADi__substituteInPlace_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, std::vector<CasADi::Matrix< CasADi::SX >* >* x2){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);+ CasADi::Matrix< CasADi::SX > x1_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x1);+ std::vector<CasADi::Matrix< CasADi::SX > > x2_ = Marshaling<std::vector<CasADi::Matrix< CasADi::SX > >,std::vector<CasADi::Matrix< CasADi::SX >* >*>::marshal(x2);++ return CasADi::substituteInPlace(x0_, x1_, x2_);+}+++// ================== function "CasADi::substituteInPlace''''" ===============+// cppName: "CasADi::substituteInPlace''''"+// cWrapperName: "CasADi__substituteInPlace_TIC_TIC_TIC_TIC"+// protoArgs: "(std::vector<CasADi::Matrix< CasADi::SX >* > * x0, std::vector<CasADi::Matrix< CasADi::SX >* >* x1, std::vector<CasADi::Matrix< CasADi::SX >* >* x2, bool* x3)"+// params: [ConstRef (Vec (NonVec (CasadiClass SXMatrix))),Ref (Vec (NonVec (CasadiClass SXMatrix))),Ref (Vec (NonVec (CasadiClass SXMatrix))),Val (NonVec CBool)]+// args: "(x0_, x1_, x2_, x3_)"+// cWrapperRetType: "void"+// proto: "void CasADi__substituteInPlace_TIC_TIC_TIC_TIC(std::vector<CasADi::Matrix< CasADi::SX >* > * x0, std::vector<CasADi::Matrix< CasADi::SX >* >* x1, std::vector<CasADi::Matrix< CasADi::SX >* >* x2, bool* x3)"+// call: "CasADi::substituteInPlace(x0_, x1_, x2_, x3_)"+extern "C"+ void CasADi__substituteInPlace_TIC_TIC_TIC_TIC(std::vector<CasADi::Matrix< CasADi::SX >* > * x0, std::vector<CasADi::Matrix< CasADi::SX >* >* x1, std::vector<CasADi::Matrix< CasADi::SX >* >* x2, bool* x3);+void CasADi__substituteInPlace_TIC_TIC_TIC_TIC(std::vector<CasADi::Matrix< CasADi::SX >* > * x0, std::vector<CasADi::Matrix< CasADi::SX >* >* x1, std::vector<CasADi::Matrix< CasADi::SX >* >* x2, bool* x3){+ std::vector<CasADi::Matrix< CasADi::SX > > x0_ = Marshaling<std::vector<CasADi::Matrix< CasADi::SX > >,std::vector<CasADi::Matrix< CasADi::SX >* > *>::marshal(x0);+ std::vector<CasADi::Matrix< CasADi::SX > > x1_ = Marshaling<std::vector<CasADi::Matrix< CasADi::SX > >,std::vector<CasADi::Matrix< CasADi::SX >* >*>::marshal(x1);+ std::vector<CasADi::Matrix< CasADi::SX > > x2_ = Marshaling<std::vector<CasADi::Matrix< CasADi::SX > >,std::vector<CasADi::Matrix< CasADi::SX >* >*>::marshal(x2);+ bool x3_ = Marshaling<bool,bool*>::marshal(x3);++ return CasADi::substituteInPlace(x0_, x1_, x2_, x3_);+}+++// ================== function "CasADi::substituteInPlace'''''" ===============+// cppName: "CasADi::substituteInPlace'''''"+// cWrapperName: "CasADi__substituteInPlace_TIC_TIC_TIC_TIC_TIC"+// protoArgs: "(std::vector<CasADi::Matrix< CasADi::SX >* > * x0, std::vector<CasADi::Matrix< CasADi::SX >* >* x1, std::vector<CasADi::Matrix< CasADi::SX >* >* x2)"+// params: [ConstRef (Vec (NonVec (CasadiClass SXMatrix))),Ref (Vec (NonVec (CasadiClass SXMatrix))),Ref (Vec (NonVec (CasadiClass SXMatrix)))]+// args: "(x0_, x1_, x2_)"+// cWrapperRetType: "void"+// proto: "void CasADi__substituteInPlace_TIC_TIC_TIC_TIC_TIC(std::vector<CasADi::Matrix< CasADi::SX >* > * x0, std::vector<CasADi::Matrix< CasADi::SX >* >* x1, std::vector<CasADi::Matrix< CasADi::SX >* >* x2)"+// call: "CasADi::substituteInPlace(x0_, x1_, x2_)"+extern "C"+ void CasADi__substituteInPlace_TIC_TIC_TIC_TIC_TIC(std::vector<CasADi::Matrix< CasADi::SX >* > * x0, std::vector<CasADi::Matrix< CasADi::SX >* >* x1, std::vector<CasADi::Matrix< CasADi::SX >* >* x2);+void CasADi__substituteInPlace_TIC_TIC_TIC_TIC_TIC(std::vector<CasADi::Matrix< CasADi::SX >* > * x0, std::vector<CasADi::Matrix< CasADi::SX >* >* x1, std::vector<CasADi::Matrix< CasADi::SX >* >* x2){+ std::vector<CasADi::Matrix< CasADi::SX > > x0_ = Marshaling<std::vector<CasADi::Matrix< CasADi::SX > >,std::vector<CasADi::Matrix< CasADi::SX >* > *>::marshal(x0);+ std::vector<CasADi::Matrix< CasADi::SX > > x1_ = Marshaling<std::vector<CasADi::Matrix< CasADi::SX > >,std::vector<CasADi::Matrix< CasADi::SX >* >*>::marshal(x1);+ std::vector<CasADi::Matrix< CasADi::SX > > x2_ = Marshaling<std::vector<CasADi::Matrix< CasADi::SX > >,std::vector<CasADi::Matrix< CasADi::SX >* >*>::marshal(x2);++ return CasADi::substituteInPlace(x0_, x1_, x2_);+}+++// ================== function "CasADi::evalf" ===============+// cppName: "CasADi::evalf"+// cWrapperName: "CasADi__evalf"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__evalf(CasADi::Matrix< CasADi::SX >* x0)"+// call: "CasADi::evalf(x0_)"+extern "C"+ CasADi::Matrix< double >* CasADi__evalf(CasADi::Matrix< CasADi::SX >* x0);+CasADi::Matrix< double >* CasADi__evalf(CasADi::Matrix< CasADi::SX >* x0){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);++ return new CasADi::Matrix< double >( CasADi::evalf(x0_) );+}+++// ================== function "CasADi::evalf'" ===============+// cppName: "CasADi::evalf'"+// cWrapperName: "CasADi__evalf_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< double >* x2)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass DMatrix))]+// args: "(x0_, x1_, x2_)"+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__evalf_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< double >* x2)"+// call: "CasADi::evalf(x0_, x1_, x2_)"+extern "C"+ CasADi::Matrix< double >* CasADi__evalf_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< double >* x2);+CasADi::Matrix< double >* CasADi__evalf_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< double >* x2){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);+ CasADi::Matrix< CasADi::SX > x1_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x1);+ CasADi::Matrix< double > x2_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x2);++ return new CasADi::Matrix< double >( CasADi::evalf(x0_, x1_, x2_) );+}+++// ================== function "CasADi::isRegular''''" ===============+// cppName: "CasADi::isRegular''''"+// cWrapperName: "CasADi__isRegular_TIC_TIC_TIC_TIC"+// protoArgs: "(CasADi::SX* x0)"+// params: [ConstRef (NonVec (CasadiClass SX))]+// args: "(x0_)"+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__isRegular_TIC_TIC_TIC_TIC(CasADi::SX* x0)"+// call: "CasADi::isRegular(x0_)"+extern "C"+ bool* CasADi__isRegular_TIC_TIC_TIC_TIC(CasADi::SX* x0);+bool* CasADi__isRegular_TIC_TIC_TIC_TIC(CasADi::SX* x0){+ CasADi::SX x0_ = Marshaling<CasADi::SX,CasADi::SX*>::marshal(x0);++ return new bool( CasADi::isRegular(x0_) );+}+++// ================== function "CasADi::isRegular'''''" ===============+// cppName: "CasADi::isRegular'''''"+// cWrapperName: "CasADi__isRegular_TIC_TIC_TIC_TIC_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix))]+// args: "(x0_)"+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__isRegular_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0)"+// call: "CasADi::isRegular(x0_)"+extern "C"+ bool* CasADi__isRegular_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0);+bool* CasADi__isRegular_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);++ return new bool( CasADi::isRegular(x0_) );+}+++// ================== function "CasADi::spy" ===============+// cppName: "CasADi::spy"+// cWrapperName: "CasADi__spy"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__spy(CasADi::Matrix< CasADi::SX >* x0)"+// call: "CasADi::spy(x0_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__spy(CasADi::Matrix< CasADi::SX >* x0);+CasADi::Matrix< CasADi::SX >* CasADi__spy(CasADi::Matrix< CasADi::SX >* x0){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);++ return new CasADi::Matrix< CasADi::SX >( CasADi::spy(x0_) );+}+++// ================== function "CasADi::dependsOn" ===============+// cppName: "CasADi::dependsOn"+// cWrapperName: "CasADi__dependsOn"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass SXMatrix))]+// args: "(x0_, x1_)"+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__dependsOn(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1)"+// call: "CasADi::dependsOn(x0_, x1_)"+extern "C"+ bool* CasADi__dependsOn(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1);+bool* CasADi__dependsOn(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);+ CasADi::Matrix< CasADi::SX > x1_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x1);++ return new bool( CasADi::dependsOn(x0_, x1_) );+}+++// ================== function "CasADi::getSymbols" ===============+// cppName: "CasADi::getSymbols"+// cWrapperName: "CasADi__getSymbols"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix))]+// args: "(x0_)"+// cWrapperRetType: "std::vector<CasADi::SX >*"+// proto: "std::vector<CasADi::SX >* CasADi__getSymbols(CasADi::Matrix< CasADi::SX >* x0)"+// call: "CasADi::getSymbols(x0_)"+extern "C"+ std::vector<CasADi::SX >* CasADi__getSymbols(CasADi::Matrix< CasADi::SX >* x0);+std::vector<CasADi::SX >* CasADi__getSymbols(CasADi::Matrix< CasADi::SX >* x0){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);++ return new std::vector<CasADi::SX >( CasADi::getSymbols(x0_) );+}+++// ================== function "CasADi::isSmooth" ===============+// cppName: "CasADi::isSmooth"+// cWrapperName: "CasADi__isSmooth"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix))]+// args: "(x0_)"+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__isSmooth(CasADi::Matrix< CasADi::SX >* x0)"+// call: "CasADi::isSmooth(x0_)"+extern "C"+ bool* CasADi__isSmooth(CasADi::Matrix< CasADi::SX >* x0);+bool* CasADi__isSmooth(CasADi::Matrix< CasADi::SX >* x0){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);++ return new bool( CasADi::isSmooth(x0_) );+}+++// ================== function "CasADi::isSymbolic" ===============+// cppName: "CasADi::isSymbolic"+// cWrapperName: "CasADi__isSymbolic"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix))]+// args: "(x0_)"+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__isSymbolic(CasADi::Matrix< CasADi::SX >* x0)"+// call: "CasADi::isSymbolic(x0_)"+extern "C"+ bool* CasADi__isSymbolic(CasADi::Matrix< CasADi::SX >* x0);+bool* CasADi__isSymbolic(CasADi::Matrix< CasADi::SX >* x0){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);++ return new bool( CasADi::isSymbolic(x0_) );+}+++// ================== function "CasADi::isSymbolicSparse" ===============+// cppName: "CasADi::isSymbolicSparse"+// cWrapperName: "CasADi__isSymbolicSparse"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix))]+// args: "(x0_)"+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__isSymbolicSparse(CasADi::Matrix< CasADi::SX >* x0)"+// call: "CasADi::isSymbolicSparse(x0_)"+extern "C"+ bool* CasADi__isSymbolicSparse(CasADi::Matrix< CasADi::SX >* x0);+bool* CasADi__isSymbolicSparse(CasADi::Matrix< CasADi::SX >* x0){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);++ return new bool( CasADi::isSymbolicSparse(x0_) );+}+++// ================== function "CasADi::jacobian" ===============+// cppName: "CasADi::jacobian"+// cWrapperName: "CasADi__jacobian"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass SXMatrix))]+// args: "(x0_, x1_)"+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__jacobian(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1)"+// call: "CasADi::jacobian(x0_, x1_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__jacobian(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1);+CasADi::Matrix< CasADi::SX >* CasADi__jacobian(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);+ CasADi::Matrix< CasADi::SX > x1_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x1);++ return new CasADi::Matrix< CasADi::SX >( CasADi::jacobian(x0_, x1_) );+}+++// ================== function "CasADi::gradient" ===============+// cppName: "CasADi::gradient"+// cWrapperName: "CasADi__gradient"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass SXMatrix))]+// args: "(x0_, x1_)"+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__gradient(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1)"+// call: "CasADi::gradient(x0_, x1_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__gradient(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1);+CasADi::Matrix< CasADi::SX >* CasADi__gradient(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);+ CasADi::Matrix< CasADi::SX > x1_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x1);++ return new CasADi::Matrix< CasADi::SX >( CasADi::gradient(x0_, x1_) );+}+++// ================== function "CasADi::tangent" ===============+// cppName: "CasADi::tangent"+// cWrapperName: "CasADi__tangent"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass SXMatrix))]+// args: "(x0_, x1_)"+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__tangent(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1)"+// call: "CasADi::tangent(x0_, x1_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__tangent(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1);+CasADi::Matrix< CasADi::SX >* CasADi__tangent(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);+ CasADi::Matrix< CasADi::SX > x1_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x1);++ return new CasADi::Matrix< CasADi::SX >( CasADi::tangent(x0_, x1_) );+}+++// ================== function "CasADi::hessian" ===============+// cppName: "CasADi::hessian"+// cWrapperName: "CasADi__hessian"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass SXMatrix))]+// args: "(x0_, x1_)"+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__hessian(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1)"+// call: "CasADi::hessian(x0_, x1_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__hessian(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1);+CasADi::Matrix< CasADi::SX >* CasADi__hessian(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);+ CasADi::Matrix< CasADi::SX > x1_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x1);++ return new CasADi::Matrix< CasADi::SX >( CasADi::hessian(x0_, x1_) );+}+++// ================== function "CasADi::hessian'" ===============+// cppName: "CasADi::hessian'"+// cWrapperName: "CasADi__hessian_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2, CasADi::Matrix< CasADi::SX >* x3)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass SXMatrix)),Ref (NonVec (CasadiClass SXMatrix)),Ref (NonVec (CasadiClass SXMatrix))]+// args: "(x0_, x1_, x2_, x3_)"+// cWrapperRetType: "void"+// proto: "void CasADi__hessian_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2, CasADi::Matrix< CasADi::SX >* x3)"+// call: "CasADi::hessian(x0_, x1_, x2_, x3_)"+extern "C"+ void CasADi__hessian_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2, CasADi::Matrix< CasADi::SX >* x3);+void CasADi__hessian_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2, CasADi::Matrix< CasADi::SX >* x3){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);+ CasADi::Matrix< CasADi::SX > x1_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x1);+ CasADi::Matrix< CasADi::SX > x2_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x2);+ CasADi::Matrix< CasADi::SX > x3_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x3);++ return CasADi::hessian(x0_, x1_, x2_, x3_);+}+++// ================== function "CasADi::jacobianTimesVector" ===============+// cppName: "CasADi::jacobianTimesVector"+// cWrapperName: "CasADi__jacobianTimesVector"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2, bool* x3)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass SXMatrix)),Val (NonVec CBool)]+// args: "(x0_, x1_, x2_, x3_)"+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__jacobianTimesVector(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2, bool* x3)"+// call: "CasADi::jacobianTimesVector(x0_, x1_, x2_, x3_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__jacobianTimesVector(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2, bool* x3);+CasADi::Matrix< CasADi::SX >* CasADi__jacobianTimesVector(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2, bool* x3){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);+ CasADi::Matrix< CasADi::SX > x1_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x1);+ CasADi::Matrix< CasADi::SX > x2_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x2);+ bool x3_ = Marshaling<bool,bool*>::marshal(x3);++ return new CasADi::Matrix< CasADi::SX >( CasADi::jacobianTimesVector(x0_, x1_, x2_, x3_) );+}+++// ================== function "CasADi::jacobianTimesVector'" ===============+// cppName: "CasADi::jacobianTimesVector'"+// cWrapperName: "CasADi__jacobianTimesVector_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass SXMatrix))]+// args: "(x0_, x1_, x2_)"+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__jacobianTimesVector_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2)"+// call: "CasADi::jacobianTimesVector(x0_, x1_, x2_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__jacobianTimesVector_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2);+CasADi::Matrix< CasADi::SX >* CasADi__jacobianTimesVector_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);+ CasADi::Matrix< CasADi::SX > x1_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x1);+ CasADi::Matrix< CasADi::SX > x2_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x2);++ return new CasADi::Matrix< CasADi::SX >( CasADi::jacobianTimesVector(x0_, x1_, x2_) );+}+++// ================== function "CasADi::getValue" ===============+// cppName: "CasADi::getValue"+// cWrapperName: "CasADi__getValue"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, int x1, int x2)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix)),Val (NonVec CInt),Val (NonVec CInt)]+// args: "(x0_, x1_, x2_)"+// cWrapperRetType: "double"+// proto: "double CasADi__getValue(CasADi::Matrix< CasADi::SX >* x0, int x1, int x2)"+// call: "CasADi::getValue(x0_, x1_, x2_)"+extern "C"+ double CasADi__getValue(CasADi::Matrix< CasADi::SX >* x0, int x1, int x2);+double CasADi__getValue(CasADi::Matrix< CasADi::SX >* x0, int x1, int x2){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);+ int x2_ = Marshaling<int,int>::marshal(x2);++ return CasADi::getValue(x0_, x1_, x2_);+}+++// ================== function "CasADi::getValue'" ===============+// cppName: "CasADi::getValue'"+// cWrapperName: "CasADi__getValue_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, int x1)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix)),Val (NonVec CInt)]+// args: "(x0_, x1_)"+// cWrapperRetType: "double"+// proto: "double CasADi__getValue_TIC(CasADi::Matrix< CasADi::SX >* x0, int x1)"+// call: "CasADi::getValue(x0_, x1_)"+extern "C"+ double CasADi__getValue_TIC(CasADi::Matrix< CasADi::SX >* x0, int x1);+double CasADi__getValue_TIC(CasADi::Matrix< CasADi::SX >* x0, int x1){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);++ return CasADi::getValue(x0_, x1_);+}+++// ================== function "CasADi::getValue''" ===============+// cppName: "CasADi::getValue''"+// cWrapperName: "CasADi__getValue_TIC_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix))]+// args: "(x0_)"+// cWrapperRetType: "double"+// proto: "double CasADi__getValue_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0)"+// call: "CasADi::getValue(x0_)"+extern "C"+ double CasADi__getValue_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0);+double CasADi__getValue_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);++ return CasADi::getValue(x0_);+}+++// ================== function "CasADi::getIntValue" ===============+// cppName: "CasADi::getIntValue"+// cWrapperName: "CasADi__getIntValue"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, int x1, int x2)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix)),Val (NonVec CInt),Val (NonVec CInt)]+// args: "(x0_, x1_, x2_)"+// cWrapperRetType: "int"+// proto: "int CasADi__getIntValue(CasADi::Matrix< CasADi::SX >* x0, int x1, int x2)"+// call: "CasADi::getIntValue(x0_, x1_, x2_)"+extern "C"+ int CasADi__getIntValue(CasADi::Matrix< CasADi::SX >* x0, int x1, int x2);+int CasADi__getIntValue(CasADi::Matrix< CasADi::SX >* x0, int x1, int x2){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);+ int x2_ = Marshaling<int,int>::marshal(x2);++ return CasADi::getIntValue(x0_, x1_, x2_);+}+++// ================== function "CasADi::getIntValue'" ===============+// cppName: "CasADi::getIntValue'"+// cWrapperName: "CasADi__getIntValue_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, int x1)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix)),Val (NonVec CInt)]+// args: "(x0_, x1_)"+// cWrapperRetType: "int"+// proto: "int CasADi__getIntValue_TIC(CasADi::Matrix< CasADi::SX >* x0, int x1)"+// call: "CasADi::getIntValue(x0_, x1_)"+extern "C"+ int CasADi__getIntValue_TIC(CasADi::Matrix< CasADi::SX >* x0, int x1);+int CasADi__getIntValue_TIC(CasADi::Matrix< CasADi::SX >* x0, int x1){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);++ return CasADi::getIntValue(x0_, x1_);+}+++// ================== function "CasADi::getIntValue''" ===============+// cppName: "CasADi::getIntValue''"+// cWrapperName: "CasADi__getIntValue_TIC_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix))]+// args: "(x0_)"+// cWrapperRetType: "int"+// proto: "int CasADi__getIntValue_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0)"+// call: "CasADi::getIntValue(x0_)"+extern "C"+ int CasADi__getIntValue_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0);+int CasADi__getIntValue_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);++ return CasADi::getIntValue(x0_);+}+++// ================== function "CasADi::fill" ===============+// cppName: "CasADi::fill"+// cWrapperName: "CasADi__fill"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, CasADi::SX* x1)"+// params: [Ref (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass SX))]+// args: "(x0_, x1_)"+// cWrapperRetType: "void"+// proto: "void CasADi__fill(CasADi::Matrix< CasADi::SX >* x0, CasADi::SX* x1)"+// call: "CasADi::fill(x0_, x1_)"+extern "C"+ void CasADi__fill(CasADi::Matrix< CasADi::SX >* x0, CasADi::SX* x1);+void CasADi__fill(CasADi::Matrix< CasADi::SX >* x0, CasADi::SX* x1){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);+ CasADi::SX x1_ = Marshaling<CasADi::SX,CasADi::SX*>::marshal(x1);++ return CasADi::fill(x0_, x1_);+}+++// ================== function "CasADi::taylor" ===============+// cppName: "CasADi::taylor"+// cWrapperName: "CasADi__taylor"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2, int x3)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass SXMatrix)),Val (NonVec CInt)]+// args: "(x0_, x1_, x2_, x3_)"+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__taylor(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2, int x3)"+// call: "CasADi::taylor(x0_, x1_, x2_, x3_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__taylor(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2, int x3);+CasADi::Matrix< CasADi::SX >* CasADi__taylor(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2, int x3){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);+ CasADi::Matrix< CasADi::SX > x1_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x1);+ CasADi::Matrix< CasADi::SX > x2_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x2);+ int x3_ = Marshaling<int,int>::marshal(x3);++ return new CasADi::Matrix< CasADi::SX >( CasADi::taylor(x0_, x1_, x2_, x3_) );+}+++// ================== function "CasADi::taylor'" ===============+// cppName: "CasADi::taylor'"+// cWrapperName: "CasADi__taylor_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass SXMatrix))]+// args: "(x0_, x1_, x2_)"+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__taylor_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2)"+// call: "CasADi::taylor(x0_, x1_, x2_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__taylor_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2);+CasADi::Matrix< CasADi::SX >* CasADi__taylor_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);+ CasADi::Matrix< CasADi::SX > x1_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x1);+ CasADi::Matrix< CasADi::SX > x2_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x2);++ return new CasADi::Matrix< CasADi::SX >( CasADi::taylor(x0_, x1_, x2_) );+}+++// ================== function "CasADi::taylor''" ===============+// cppName: "CasADi::taylor''"+// cWrapperName: "CasADi__taylor_TIC_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass SXMatrix))]+// args: "(x0_, x1_)"+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__taylor_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1)"+// call: "CasADi::taylor(x0_, x1_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__taylor_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1);+CasADi::Matrix< CasADi::SX >* CasADi__taylor_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);+ CasADi::Matrix< CasADi::SX > x1_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x1);++ return new CasADi::Matrix< CasADi::SX >( CasADi::taylor(x0_, x1_) );+}+++// ================== function "CasADi::mtaylor" ===============+// cppName: "CasADi::mtaylor"+// cWrapperName: "CasADi__mtaylor"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2, int x3)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass SXMatrix)),Val (NonVec CInt)]+// args: "(x0_, x1_, x2_, x3_)"+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__mtaylor(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2, int x3)"+// call: "CasADi::mtaylor(x0_, x1_, x2_, x3_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__mtaylor(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2, int x3);+CasADi::Matrix< CasADi::SX >* CasADi__mtaylor(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2, int x3){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);+ CasADi::Matrix< CasADi::SX > x1_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x1);+ CasADi::Matrix< CasADi::SX > x2_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x2);+ int x3_ = Marshaling<int,int>::marshal(x3);++ return new CasADi::Matrix< CasADi::SX >( CasADi::mtaylor(x0_, x1_, x2_, x3_) );+}+++// ================== function "CasADi::mtaylor'" ===============+// cppName: "CasADi::mtaylor'"+// cWrapperName: "CasADi__mtaylor_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass SXMatrix))]+// args: "(x0_, x1_, x2_)"+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__mtaylor_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2)"+// call: "CasADi::mtaylor(x0_, x1_, x2_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__mtaylor_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2);+CasADi::Matrix< CasADi::SX >* CasADi__mtaylor_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);+ CasADi::Matrix< CasADi::SX > x1_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x1);+ CasADi::Matrix< CasADi::SX > x2_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x2);++ return new CasADi::Matrix< CasADi::SX >( CasADi::mtaylor(x0_, x1_, x2_) );+}+++// ================== function "CasADi::mtaylor''" ===============+// cppName: "CasADi::mtaylor''"+// cWrapperName: "CasADi__mtaylor_TIC_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2, int x3, std::vector<int > * x4)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass SXMatrix)),Val (NonVec CInt),ConstRef (Vec (NonVec CInt))]+// args: "(x0_, x1_, x2_, x3_, x4_)"+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__mtaylor_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2, int x3, std::vector<int > * x4)"+// call: "CasADi::mtaylor(x0_, x1_, x2_, x3_, x4_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__mtaylor_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2, int x3, std::vector<int > * x4);+CasADi::Matrix< CasADi::SX >* CasADi__mtaylor_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, CasADi::Matrix< CasADi::SX >* x2, int x3, std::vector<int > * x4){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);+ CasADi::Matrix< CasADi::SX > x1_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x1);+ CasADi::Matrix< CasADi::SX > x2_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x2);+ int x3_ = Marshaling<int,int>::marshal(x3);+ std::vector<int > x4_ = Marshaling<std::vector<int >,std::vector<int > *>::marshal(x4);++ return new CasADi::Matrix< CasADi::SX >( CasADi::mtaylor(x0_, x1_, x2_, x3_, x4_) );+}+++// ================== function "CasADi::countNodes" ===============+// cppName: "CasADi::countNodes"+// cWrapperName: "CasADi__countNodes"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix))]+// args: "(x0_)"+// cWrapperRetType: "int"+// proto: "int CasADi__countNodes(CasADi::Matrix< CasADi::SX >* x0)"+// call: "CasADi::countNodes(x0_)"+extern "C"+ int CasADi__countNodes(CasADi::Matrix< CasADi::SX >* x0);+int CasADi__countNodes(CasADi::Matrix< CasADi::SX >* x0){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);++ return CasADi::countNodes(x0_);+}+++// ================== function "CasADi::getOperatorRepresentation" ===============+// cppName: "CasADi::getOperatorRepresentation"+// cWrapperName: "CasADi__getOperatorRepresentation"+// protoArgs: "(CasADi::SX* x0, std::vector<std::string* > * x1)"+// params: [ConstRef (NonVec (CasadiClass SX)),ConstRef (Vec (NonVec StdString))]+// args: "(x0_, x1_)"+// cWrapperRetType: "std::string*"+// proto: "std::string* CasADi__getOperatorRepresentation(CasADi::SX* x0, std::vector<std::string* > * x1)"+// call: "CasADi::getOperatorRepresentation(x0_, x1_)"+extern "C"+ std::string* CasADi__getOperatorRepresentation(CasADi::SX* x0, std::vector<std::string* > * x1);+std::string* CasADi__getOperatorRepresentation(CasADi::SX* x0, std::vector<std::string* > * x1){+ CasADi::SX x0_ = Marshaling<CasADi::SX,CasADi::SX*>::marshal(x0);+ std::vector<std::string > x1_ = Marshaling<std::vector<std::string >,std::vector<std::string* > *>::marshal(x1);++ return new std::string( CasADi::getOperatorRepresentation(x0_, x1_) );+}+++// ================== function "CasADi::getFree" ===============+// cppName: "CasADi::getFree"+// cWrapperName: "CasADi__getFree"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__getFree(CasADi::Matrix< CasADi::SX >* x0)"+// call: "CasADi::getFree(x0_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__getFree(CasADi::Matrix< CasADi::SX >* x0);+CasADi::Matrix< CasADi::SX >* CasADi__getFree(CasADi::Matrix< CasADi::SX >* x0){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);++ return new CasADi::Matrix< CasADi::SX >( CasADi::getFree(x0_) );+}+++// ================== function "CasADi::extractShared" ===============+// cppName: "CasADi::extractShared"+// cWrapperName: "CasADi__extractShared"+// protoArgs: "(std::vector<CasADi::SX* >* x0, std::vector<CasADi::SX* >* x1, std::vector<CasADi::SX* >* x2, std::string* x3, std::string* x4)"+// params: [Ref (Vec (NonVec (CasadiClass SX))),Ref (Vec (NonVec (CasadiClass SX))),Ref (Vec (NonVec (CasadiClass SX))),ConstRef (NonVec StdString),ConstRef (NonVec StdString)]+// args: "(x0_, x1_, x2_, x3_, x4_)"+// cWrapperRetType: "void"+// proto: "void CasADi__extractShared(std::vector<CasADi::SX* >* x0, std::vector<CasADi::SX* >* x1, std::vector<CasADi::SX* >* x2, std::string* x3, std::string* x4)"+// call: "CasADi::extractShared(x0_, x1_, x2_, x3_, x4_)"+extern "C"+ void CasADi__extractShared(std::vector<CasADi::SX* >* x0, std::vector<CasADi::SX* >* x1, std::vector<CasADi::SX* >* x2, std::string* x3, std::string* x4);+void CasADi__extractShared(std::vector<CasADi::SX* >* x0, std::vector<CasADi::SX* >* x1, std::vector<CasADi::SX* >* x2, std::string* x3, std::string* x4){+ std::vector<CasADi::SX > x0_ = Marshaling<std::vector<CasADi::SX >,std::vector<CasADi::SX* >*>::marshal(x0);+ std::vector<CasADi::SX > x1_ = Marshaling<std::vector<CasADi::SX >,std::vector<CasADi::SX* >*>::marshal(x1);+ std::vector<CasADi::SX > x2_ = Marshaling<std::vector<CasADi::SX >,std::vector<CasADi::SX* >*>::marshal(x2);+ std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);+ std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);++ return CasADi::extractShared(x0_, x1_, x2_, x3_, x4_);+}+++// ================== function "CasADi::extractShared'" ===============+// cppName: "CasADi::extractShared'"+// cWrapperName: "CasADi__extractShared_TIC"+// protoArgs: "(std::vector<CasADi::SX* >* x0, std::vector<CasADi::SX* >* x1, std::vector<CasADi::SX* >* x2, std::string* x3)"+// params: [Ref (Vec (NonVec (CasadiClass SX))),Ref (Vec (NonVec (CasadiClass SX))),Ref (Vec (NonVec (CasadiClass SX))),ConstRef (NonVec StdString)]+// args: "(x0_, x1_, x2_, x3_)"+// cWrapperRetType: "void"+// proto: "void CasADi__extractShared_TIC(std::vector<CasADi::SX* >* x0, std::vector<CasADi::SX* >* x1, std::vector<CasADi::SX* >* x2, std::string* x3)"+// call: "CasADi::extractShared(x0_, x1_, x2_, x3_)"+extern "C"+ void CasADi__extractShared_TIC(std::vector<CasADi::SX* >* x0, std::vector<CasADi::SX* >* x1, std::vector<CasADi::SX* >* x2, std::string* x3);+void CasADi__extractShared_TIC(std::vector<CasADi::SX* >* x0, std::vector<CasADi::SX* >* x1, std::vector<CasADi::SX* >* x2, std::string* x3){+ std::vector<CasADi::SX > x0_ = Marshaling<std::vector<CasADi::SX >,std::vector<CasADi::SX* >*>::marshal(x0);+ std::vector<CasADi::SX > x1_ = Marshaling<std::vector<CasADi::SX >,std::vector<CasADi::SX* >*>::marshal(x1);+ std::vector<CasADi::SX > x2_ = Marshaling<std::vector<CasADi::SX >,std::vector<CasADi::SX* >*>::marshal(x2);+ std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);++ return CasADi::extractShared(x0_, x1_, x2_, x3_);+}+++// ================== function "CasADi::extractShared''" ===============+// cppName: "CasADi::extractShared''"+// cWrapperName: "CasADi__extractShared_TIC_TIC"+// protoArgs: "(std::vector<CasADi::SX* >* x0, std::vector<CasADi::SX* >* x1, std::vector<CasADi::SX* >* x2)"+// params: [Ref (Vec (NonVec (CasadiClass SX))),Ref (Vec (NonVec (CasadiClass SX))),Ref (Vec (NonVec (CasadiClass SX)))]+// args: "(x0_, x1_, x2_)"+// cWrapperRetType: "void"+// proto: "void CasADi__extractShared_TIC_TIC(std::vector<CasADi::SX* >* x0, std::vector<CasADi::SX* >* x1, std::vector<CasADi::SX* >* x2)"+// call: "CasADi::extractShared(x0_, x1_, x2_)"+extern "C"+ void CasADi__extractShared_TIC_TIC(std::vector<CasADi::SX* >* x0, std::vector<CasADi::SX* >* x1, std::vector<CasADi::SX* >* x2);+void CasADi__extractShared_TIC_TIC(std::vector<CasADi::SX* >* x0, std::vector<CasADi::SX* >* x1, std::vector<CasADi::SX* >* x2){+ std::vector<CasADi::SX > x0_ = Marshaling<std::vector<CasADi::SX >,std::vector<CasADi::SX* >*>::marshal(x0);+ std::vector<CasADi::SX > x1_ = Marshaling<std::vector<CasADi::SX >,std::vector<CasADi::SX* >*>::marshal(x1);+ std::vector<CasADi::SX > x2_ = Marshaling<std::vector<CasADi::SX >,std::vector<CasADi::SX* >*>::marshal(x2);++ return CasADi::extractShared(x0_, x1_, x2_);+}+++// ================== function "CasADi::printCompact'" ===============+// cppName: "CasADi::printCompact'"+// cWrapperName: "CasADi__printCompact_TIC"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix))]+// args: "(x0_)"+// cWrapperRetType: "void"+// proto: "void CasADi__printCompact_TIC(CasADi::Matrix< CasADi::SX >* x0)"+// call: "CasADi::printCompact(x0_)"+extern "C"+ void CasADi__printCompact_TIC(CasADi::Matrix< CasADi::SX >* x0);+void CasADi__printCompact_TIC(CasADi::Matrix< CasADi::SX >* x0){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);++ return CasADi::printCompact(x0_);+}+++// ================== function "CasADi::poly_coeff" ===============+// cppName: "CasADi::poly_coeff"+// cWrapperName: "CasADi__poly_coeff"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (NonVec (CasadiClass SXMatrix))]+// args: "(x0_, x1_)"+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__poly_coeff(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1)"+// call: "CasADi::poly_coeff(x0_, x1_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__poly_coeff(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1);+CasADi::Matrix< CasADi::SX >* CasADi__poly_coeff(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);+ CasADi::Matrix< CasADi::SX > x1_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x1);++ return new CasADi::Matrix< CasADi::SX >( CasADi::poly_coeff(x0_, x1_) );+}+++// ================== function "CasADi::poly_roots" ===============+// cppName: "CasADi::poly_roots"+// cWrapperName: "CasADi__poly_roots"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__poly_roots(CasADi::Matrix< CasADi::SX >* x0)"+// call: "CasADi::poly_roots(x0_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__poly_roots(CasADi::Matrix< CasADi::SX >* x0);+CasADi::Matrix< CasADi::SX >* CasADi__poly_roots(CasADi::Matrix< CasADi::SX >* x0){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);++ return new CasADi::Matrix< CasADi::SX >( CasADi::poly_roots(x0_) );+}+++// ================== function "CasADi::eig_symbolic" ===============+// cppName: "CasADi::eig_symbolic"+// cWrapperName: "CasADi__eig_symbolic"+// protoArgs: "(CasADi::Matrix< CasADi::SX >* x0)"+// params: [ConstRef (NonVec (CasadiClass SXMatrix))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::Matrix< CasADi::SX >*"+// proto: "CasADi::Matrix< CasADi::SX >* CasADi__eig_symbolic(CasADi::Matrix< CasADi::SX >* x0)"+// call: "CasADi::eig_symbolic(x0_)"+extern "C"+ CasADi::Matrix< CasADi::SX >* CasADi__eig_symbolic(CasADi::Matrix< CasADi::SX >* x0);+CasADi::Matrix< CasADi::SX >* CasADi__eig_symbolic(CasADi::Matrix< CasADi::SX >* x0){+ CasADi::Matrix< CasADi::SX > x0_ = Marshaling<CasADi::Matrix< CasADi::SX >,CasADi::Matrix< CasADi::SX >*>::marshal(x0);++ return new CasADi::Matrix< CasADi::SX >( CasADi::eig_symbolic(x0_) );+}+++// ================== function "CasADi::vertcat''''" ===============+// cppName: "CasADi::vertcat''''"+// cWrapperName: "CasADi__vertcat_TIC_TIC_TIC_TIC"+// protoArgs: "(std::vector<CasADi::MX* > * x0)"+// params: [ConstRef (Vec (NonVec (CasadiClass MX)))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__vertcat_TIC_TIC_TIC_TIC(std::vector<CasADi::MX* > * x0)"+// call: "CasADi::vertcat(x0_)"+extern "C"+ CasADi::MX* CasADi__vertcat_TIC_TIC_TIC_TIC(std::vector<CasADi::MX* > * x0);+CasADi::MX* CasADi__vertcat_TIC_TIC_TIC_TIC(std::vector<CasADi::MX* > * x0){+ std::vector<CasADi::MX > x0_ = Marshaling<std::vector<CasADi::MX >,std::vector<CasADi::MX* > *>::marshal(x0);++ return new CasADi::MX( CasADi::vertcat(x0_) );+}+++// ================== function "CasADi::vertsplit'''''''''" ===============+// cppName: "CasADi::vertsplit'''''''''"+// cWrapperName: "CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"+// protoArgs: "(CasADi::MX* x0, std::vector<int > * x1)"+// params: [ConstRef (NonVec (CasadiClass MX)),ConstRef (Vec (NonVec CInt))]+// args: "(x0_, x1_)"+// cWrapperRetType: "std::vector<CasADi::MX >*"+// proto: "std::vector<CasADi::MX >* CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0, std::vector<int > * x1)"+// call: "CasADi::vertsplit(x0_, x1_)"+extern "C"+ std::vector<CasADi::MX >* CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0, std::vector<int > * x1);+std::vector<CasADi::MX >* CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0, std::vector<int > * x1){+ CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);+ std::vector<int > x1_ = Marshaling<std::vector<int >,std::vector<int > *>::marshal(x1);++ return new std::vector<CasADi::MX >( CasADi::vertsplit(x0_, x1_) );+}+++// ================== function "CasADi::vertsplit''''''''''" ===============+// cppName: "CasADi::vertsplit''''''''''"+// cWrapperName: "CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"+// protoArgs: "(CasADi::MX* x0, int x1)"+// params: [ConstRef (NonVec (CasadiClass MX)),Val (NonVec CInt)]+// args: "(x0_, x1_)"+// cWrapperRetType: "std::vector<CasADi::MX >*"+// proto: "std::vector<CasADi::MX >* CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0, int x1)"+// call: "CasADi::vertsplit(x0_, x1_)"+extern "C"+ std::vector<CasADi::MX >* CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0, int x1);+std::vector<CasADi::MX >* CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0, int x1){+ CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);++ return new std::vector<CasADi::MX >( CasADi::vertsplit(x0_, x1_) );+}+++// ================== function "CasADi::vertsplit'''''''''''" ===============+// cppName: "CasADi::vertsplit'''''''''''"+// cWrapperName: "CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"+// protoArgs: "(CasADi::MX* x0)"+// params: [ConstRef (NonVec (CasadiClass MX))]+// args: "(x0_)"+// cWrapperRetType: "std::vector<CasADi::MX >*"+// proto: "std::vector<CasADi::MX >* CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0)"+// call: "CasADi::vertsplit(x0_)"+extern "C"+ std::vector<CasADi::MX >* CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0);+std::vector<CasADi::MX >* CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0){+ CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);++ return new std::vector<CasADi::MX >( CasADi::vertsplit(x0_) );+}+++// ================== function "CasADi::horzcat''''" ===============+// cppName: "CasADi::horzcat''''"+// cWrapperName: "CasADi__horzcat_TIC_TIC_TIC_TIC"+// protoArgs: "(std::vector<CasADi::MX* > * x0)"+// params: [ConstRef (Vec (NonVec (CasadiClass MX)))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__horzcat_TIC_TIC_TIC_TIC(std::vector<CasADi::MX* > * x0)"+// call: "CasADi::horzcat(x0_)"+extern "C"+ CasADi::MX* CasADi__horzcat_TIC_TIC_TIC_TIC(std::vector<CasADi::MX* > * x0);+CasADi::MX* CasADi__horzcat_TIC_TIC_TIC_TIC(std::vector<CasADi::MX* > * x0){+ std::vector<CasADi::MX > x0_ = Marshaling<std::vector<CasADi::MX >,std::vector<CasADi::MX* > *>::marshal(x0);++ return new CasADi::MX( CasADi::horzcat(x0_) );+}+++// ================== function "CasADi::horzsplit'''''''''" ===============+// cppName: "CasADi::horzsplit'''''''''"+// cWrapperName: "CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"+// protoArgs: "(CasADi::MX* x0, std::vector<int > * x1)"+// params: [ConstRef (NonVec (CasadiClass MX)),ConstRef (Vec (NonVec CInt))]+// args: "(x0_, x1_)"+// cWrapperRetType: "std::vector<CasADi::MX >*"+// proto: "std::vector<CasADi::MX >* CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0, std::vector<int > * x1)"+// call: "CasADi::horzsplit(x0_, x1_)"+extern "C"+ std::vector<CasADi::MX >* CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0, std::vector<int > * x1);+std::vector<CasADi::MX >* CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0, std::vector<int > * x1){+ CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);+ std::vector<int > x1_ = Marshaling<std::vector<int >,std::vector<int > *>::marshal(x1);++ return new std::vector<CasADi::MX >( CasADi::horzsplit(x0_, x1_) );+}+++// ================== function "CasADi::horzsplit''''''''''" ===============+// cppName: "CasADi::horzsplit''''''''''"+// cWrapperName: "CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"+// protoArgs: "(CasADi::MX* x0, int x1)"+// params: [ConstRef (NonVec (CasadiClass MX)),Val (NonVec CInt)]+// args: "(x0_, x1_)"+// cWrapperRetType: "std::vector<CasADi::MX >*"+// proto: "std::vector<CasADi::MX >* CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0, int x1)"+// call: "CasADi::horzsplit(x0_, x1_)"+extern "C"+ std::vector<CasADi::MX >* CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0, int x1);+std::vector<CasADi::MX >* CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0, int x1){+ CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);++ return new std::vector<CasADi::MX >( CasADi::horzsplit(x0_, x1_) );+}+++// ================== function "CasADi::horzsplit'''''''''''" ===============+// cppName: "CasADi::horzsplit'''''''''''"+// cWrapperName: "CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"+// protoArgs: "(CasADi::MX* x0)"+// params: [ConstRef (NonVec (CasadiClass MX))]+// args: "(x0_)"+// cWrapperRetType: "std::vector<CasADi::MX >*"+// proto: "std::vector<CasADi::MX >* CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0)"+// call: "CasADi::horzsplit(x0_)"+extern "C"+ std::vector<CasADi::MX >* CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0);+std::vector<CasADi::MX >* CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0){+ CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);++ return new std::vector<CasADi::MX >( CasADi::horzsplit(x0_) );+}+++// ================== function "CasADi::blockcat'''" ===============+// cppName: "CasADi::blockcat'''"+// cWrapperName: "CasADi__blockcat_TIC_TIC_TIC"+// protoArgs: "(std::vector<std::vector<CasADi::MX* > > * x0)"+// params: [ConstRef (Vec (Vec (NonVec (CasadiClass MX))))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__blockcat_TIC_TIC_TIC(std::vector<std::vector<CasADi::MX* > > * x0)"+// call: "CasADi::blockcat(x0_)"+extern "C"+ CasADi::MX* CasADi__blockcat_TIC_TIC_TIC(std::vector<std::vector<CasADi::MX* > > * x0);+CasADi::MX* CasADi__blockcat_TIC_TIC_TIC(std::vector<std::vector<CasADi::MX* > > * x0){+ std::vector<std::vector<CasADi::MX > > x0_ = Marshaling<std::vector<std::vector<CasADi::MX > >,std::vector<std::vector<CasADi::MX* > > *>::marshal(x0);++ return new CasADi::MX( CasADi::blockcat(x0_) );+}+++// ================== function "CasADi::blocksplit''''''''''''" ===============+// cppName: "CasADi::blocksplit''''''''''''"+// cWrapperName: "CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"+// protoArgs: "(CasADi::MX* x0, std::vector<int > * x1, std::vector<int > * x2)"+// params: [ConstRef (NonVec (CasadiClass MX)),ConstRef (Vec (NonVec CInt)),ConstRef (Vec (NonVec CInt))]+// args: "(x0_, x1_, x2_)"+// cWrapperRetType: "std::vector<std::vector<CasADi::MX > >*"+// proto: "std::vector<std::vector<CasADi::MX > >* CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0, std::vector<int > * x1, std::vector<int > * x2)"+// call: "CasADi::blocksplit(x0_, x1_, x2_)"+extern "C"+ std::vector<std::vector<CasADi::MX > >* CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0, std::vector<int > * x1, std::vector<int > * x2);+std::vector<std::vector<CasADi::MX > >* CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0, std::vector<int > * x1, std::vector<int > * x2){+ CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);+ std::vector<int > x1_ = Marshaling<std::vector<int >,std::vector<int > *>::marshal(x1);+ std::vector<int > x2_ = Marshaling<std::vector<int >,std::vector<int > *>::marshal(x2);++ return new std::vector<std::vector<CasADi::MX > >( CasADi::blocksplit(x0_, x1_, x2_) );+}+++// ================== function "CasADi::blocksplit'''''''''''''" ===============+// cppName: "CasADi::blocksplit'''''''''''''"+// cWrapperName: "CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"+// protoArgs: "(CasADi::MX* x0, int x1, int x2)"+// params: [ConstRef (NonVec (CasadiClass MX)),Val (NonVec CInt),Val (NonVec CInt)]+// args: "(x0_, x1_, x2_)"+// cWrapperRetType: "std::vector<std::vector<CasADi::MX > >*"+// proto: "std::vector<std::vector<CasADi::MX > >* CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0, int x1, int x2)"+// call: "CasADi::blocksplit(x0_, x1_, x2_)"+extern "C"+ std::vector<std::vector<CasADi::MX > >* CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0, int x1, int x2);+std::vector<std::vector<CasADi::MX > >* CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0, int x1, int x2){+ CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);+ int x2_ = Marshaling<int,int>::marshal(x2);++ return new std::vector<std::vector<CasADi::MX > >( CasADi::blocksplit(x0_, x1_, x2_) );+}+++// ================== function "CasADi::blocksplit''''''''''''''" ===============+// cppName: "CasADi::blocksplit''''''''''''''"+// cWrapperName: "CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"+// protoArgs: "(CasADi::MX* x0, int x1)"+// params: [ConstRef (NonVec (CasadiClass MX)),Val (NonVec CInt)]+// args: "(x0_, x1_)"+// cWrapperRetType: "std::vector<std::vector<CasADi::MX > >*"+// proto: "std::vector<std::vector<CasADi::MX > >* CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0, int x1)"+// call: "CasADi::blocksplit(x0_, x1_)"+extern "C"+ std::vector<std::vector<CasADi::MX > >* CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0, int x1);+std::vector<std::vector<CasADi::MX > >* CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0, int x1){+ CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);++ return new std::vector<std::vector<CasADi::MX > >( CasADi::blocksplit(x0_, x1_) );+}+++// ================== function "CasADi::blocksplit'''''''''''''''" ===============+// cppName: "CasADi::blocksplit'''''''''''''''"+// cWrapperName: "CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"+// protoArgs: "(CasADi::MX* x0)"+// params: [ConstRef (NonVec (CasadiClass MX))]+// args: "(x0_)"+// cWrapperRetType: "std::vector<std::vector<CasADi::MX > >*"+// proto: "std::vector<std::vector<CasADi::MX > >* CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0)"+// call: "CasADi::blocksplit(x0_)"+extern "C"+ std::vector<std::vector<CasADi::MX > >* CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0);+std::vector<std::vector<CasADi::MX > >* CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0){+ CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);++ return new std::vector<std::vector<CasADi::MX > >( CasADi::blocksplit(x0_) );+}+++// ================== function "CasADi::veccat'''" ===============+// cppName: "CasADi::veccat'''"+// cWrapperName: "CasADi__veccat_TIC_TIC_TIC"+// protoArgs: "(std::vector<CasADi::MX* > * x0)"+// params: [ConstRef (Vec (NonVec (CasadiClass MX)))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__veccat_TIC_TIC_TIC(std::vector<CasADi::MX* > * x0)"+// call: "CasADi::veccat(x0_)"+extern "C"+ CasADi::MX* CasADi__veccat_TIC_TIC_TIC(std::vector<CasADi::MX* > * x0);+CasADi::MX* CasADi__veccat_TIC_TIC_TIC(std::vector<CasADi::MX* > * x0){+ std::vector<CasADi::MX > x0_ = Marshaling<std::vector<CasADi::MX >,std::vector<CasADi::MX* > *>::marshal(x0);++ return new CasADi::MX( CasADi::veccat(x0_) );+}+++// ================== function "CasADi::flattencat'''" ===============+// cppName: "CasADi::flattencat'''"+// cWrapperName: "CasADi__flattencat_TIC_TIC_TIC"+// protoArgs: "(std::vector<CasADi::MX* > * x0)"+// params: [ConstRef (Vec (NonVec (CasadiClass MX)))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__flattencat_TIC_TIC_TIC(std::vector<CasADi::MX* > * x0)"+// call: "CasADi::flattencat(x0_)"+extern "C"+ CasADi::MX* CasADi__flattencat_TIC_TIC_TIC(std::vector<CasADi::MX* > * x0);+CasADi::MX* CasADi__flattencat_TIC_TIC_TIC(std::vector<CasADi::MX* > * x0){+ std::vector<CasADi::MX > x0_ = Marshaling<std::vector<CasADi::MX >,std::vector<CasADi::MX* > *>::marshal(x0);++ return new CasADi::MX( CasADi::flattencat(x0_) );+}+++// ================== function "CasADi::vecNZcat'''" ===============+// cppName: "CasADi::vecNZcat'''"+// cWrapperName: "CasADi__vecNZcat_TIC_TIC_TIC"+// protoArgs: "(std::vector<CasADi::MX* > * x0)"+// params: [ConstRef (Vec (NonVec (CasadiClass MX)))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__vecNZcat_TIC_TIC_TIC(std::vector<CasADi::MX* > * x0)"+// call: "CasADi::vecNZcat(x0_)"+extern "C"+ CasADi::MX* CasADi__vecNZcat_TIC_TIC_TIC(std::vector<CasADi::MX* > * x0);+CasADi::MX* CasADi__vecNZcat_TIC_TIC_TIC(std::vector<CasADi::MX* > * x0){+ std::vector<CasADi::MX > x0_ = Marshaling<std::vector<CasADi::MX >,std::vector<CasADi::MX* > *>::marshal(x0);++ return new CasADi::MX( CasADi::vecNZcat(x0_) );+}+++// ================== function "CasADi::flattenNZcat'''" ===============+// cppName: "CasADi::flattenNZcat'''"+// cWrapperName: "CasADi__flattenNZcat_TIC_TIC_TIC"+// protoArgs: "(std::vector<CasADi::MX* > * x0)"+// params: [ConstRef (Vec (NonVec (CasadiClass MX)))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__flattenNZcat_TIC_TIC_TIC(std::vector<CasADi::MX* > * x0)"+// call: "CasADi::flattenNZcat(x0_)"+extern "C"+ CasADi::MX* CasADi__flattenNZcat_TIC_TIC_TIC(std::vector<CasADi::MX* > * x0);+CasADi::MX* CasADi__flattenNZcat_TIC_TIC_TIC(std::vector<CasADi::MX* > * x0){+ std::vector<CasADi::MX > x0_ = Marshaling<std::vector<CasADi::MX >,std::vector<CasADi::MX* > *>::marshal(x0);++ return new CasADi::MX( CasADi::flattenNZcat(x0_) );+}+++// ================== function "CasADi::norm_F'''" ===============+// cppName: "CasADi::norm_F'''"+// cWrapperName: "CasADi__norm_F_TIC_TIC_TIC"+// protoArgs: "(CasADi::MX* x0)"+// params: [ConstRef (NonVec (CasadiClass MX))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__norm_F_TIC_TIC_TIC(CasADi::MX* x0)"+// call: "CasADi::norm_F(x0_)"+extern "C"+ CasADi::MX* CasADi__norm_F_TIC_TIC_TIC(CasADi::MX* x0);+CasADi::MX* CasADi__norm_F_TIC_TIC_TIC(CasADi::MX* x0){+ CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);++ return new CasADi::MX( CasADi::norm_F(x0_) );+}+++// ================== function "CasADi::norm_2'''" ===============+// cppName: "CasADi::norm_2'''"+// cWrapperName: "CasADi__norm_2_TIC_TIC_TIC"+// protoArgs: "(CasADi::MX* x0)"+// params: [ConstRef (NonVec (CasadiClass MX))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__norm_2_TIC_TIC_TIC(CasADi::MX* x0)"+// call: "CasADi::norm_2(x0_)"+extern "C"+ CasADi::MX* CasADi__norm_2_TIC_TIC_TIC(CasADi::MX* x0);+CasADi::MX* CasADi__norm_2_TIC_TIC_TIC(CasADi::MX* x0){+ CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);++ return new CasADi::MX( CasADi::norm_2(x0_) );+}+++// ================== function "CasADi::norm_1'''" ===============+// cppName: "CasADi::norm_1'''"+// cWrapperName: "CasADi__norm_1_TIC_TIC_TIC"+// protoArgs: "(CasADi::MX* x0)"+// params: [ConstRef (NonVec (CasadiClass MX))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__norm_1_TIC_TIC_TIC(CasADi::MX* x0)"+// call: "CasADi::norm_1(x0_)"+extern "C"+ CasADi::MX* CasADi__norm_1_TIC_TIC_TIC(CasADi::MX* x0);+CasADi::MX* CasADi__norm_1_TIC_TIC_TIC(CasADi::MX* x0){+ CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);++ return new CasADi::MX( CasADi::norm_1(x0_) );+}+++// ================== function "CasADi::norm_inf'''" ===============+// cppName: "CasADi::norm_inf'''"+// cWrapperName: "CasADi__norm_inf_TIC_TIC_TIC"+// protoArgs: "(CasADi::MX* x0)"+// params: [ConstRef (NonVec (CasadiClass MX))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__norm_inf_TIC_TIC_TIC(CasADi::MX* x0)"+// call: "CasADi::norm_inf(x0_)"+extern "C"+ CasADi::MX* CasADi__norm_inf_TIC_TIC_TIC(CasADi::MX* x0);+CasADi::MX* CasADi__norm_inf_TIC_TIC_TIC(CasADi::MX* x0){+ CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);++ return new CasADi::MX( CasADi::norm_inf(x0_) );+}+++// ================== function "CasADi::trans''''" ===============+// cppName: "CasADi::trans''''"+// cWrapperName: "CasADi__trans_TIC_TIC_TIC_TIC"+// protoArgs: "(CasADi::MX* x0)"+// params: [ConstRef (NonVec (CasadiClass MX))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__trans_TIC_TIC_TIC_TIC(CasADi::MX* x0)"+// call: "CasADi::trans(x0_)"+extern "C"+ CasADi::MX* CasADi__trans_TIC_TIC_TIC_TIC(CasADi::MX* x0);+CasADi::MX* CasADi__trans_TIC_TIC_TIC_TIC(CasADi::MX* x0){+ CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);++ return new CasADi::MX( CasADi::trans(x0_) );+}+++// ================== function "CasADi::mul''''''''''" ===============+// cppName: "CasADi::mul''''''''''"+// cWrapperName: "CasADi__mul_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"+// protoArgs: "(CasADi::MX* x0, CasADi::MX* x1, CasADi::CRSSparsity* x2)"+// params: [ConstRef (NonVec (CasadiClass MX)),ConstRef (NonVec (CasadiClass MX)),ConstRef (NonVec (CasadiClass CRSSparsity))]+// args: "(x0_, x1_, x2_)"+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__mul_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0, CasADi::MX* x1, CasADi::CRSSparsity* x2)"+// call: "CasADi::mul(x0_, x1_, x2_)"+extern "C"+ CasADi::MX* CasADi__mul_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0, CasADi::MX* x1, CasADi::CRSSparsity* x2);+CasADi::MX* CasADi__mul_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0, CasADi::MX* x1, CasADi::CRSSparsity* x2){+ CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);+ CasADi::MX x1_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x1);+ CasADi::CRSSparsity x2_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x2);++ return new CasADi::MX( CasADi::mul(x0_, x1_, x2_) );+}+++// ================== function "CasADi::mul'''''''''''" ===============+// cppName: "CasADi::mul'''''''''''"+// cWrapperName: "CasADi__mul_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"+// protoArgs: "(CasADi::MX* x0, CasADi::MX* x1)"+// params: [ConstRef (NonVec (CasadiClass MX)),ConstRef (NonVec (CasadiClass MX))]+// args: "(x0_, x1_)"+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__mul_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0, CasADi::MX* x1)"+// call: "CasADi::mul(x0_, x1_)"+extern "C"+ CasADi::MX* CasADi__mul_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0, CasADi::MX* x1);+CasADi::MX* CasADi__mul_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0, CasADi::MX* x1){+ CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);+ CasADi::MX x1_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x1);++ return new CasADi::MX( CasADi::mul(x0_, x1_) );+}+++// ================== function "CasADi::mul''''''''''''" ===============+// cppName: "CasADi::mul''''''''''''"+// cWrapperName: "CasADi__mul_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"+// protoArgs: "(std::vector<CasADi::MX* > * x0)"+// params: [ConstRef (Vec (NonVec (CasadiClass MX)))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__mul_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector<CasADi::MX* > * x0)"+// call: "CasADi::mul(x0_)"+extern "C"+ CasADi::MX* CasADi__mul_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector<CasADi::MX* > * x0);+CasADi::MX* CasADi__mul_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector<CasADi::MX* > * x0){+ std::vector<CasADi::MX > x0_ = Marshaling<std::vector<CasADi::MX >,std::vector<CasADi::MX* > *>::marshal(x0);++ return new CasADi::MX( CasADi::mul(x0_) );+}+++// ================== function "CasADi::inner_prod'''" ===============+// cppName: "CasADi::inner_prod'''"+// cWrapperName: "CasADi__inner_prod_TIC_TIC_TIC"+// protoArgs: "(CasADi::MX* x0, CasADi::MX* x1)"+// params: [ConstRef (NonVec (CasadiClass MX)),ConstRef (NonVec (CasadiClass MX))]+// args: "(x0_, x1_)"+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__inner_prod_TIC_TIC_TIC(CasADi::MX* x0, CasADi::MX* x1)"+// call: "CasADi::inner_prod(x0_, x1_)"+extern "C"+ CasADi::MX* CasADi__inner_prod_TIC_TIC_TIC(CasADi::MX* x0, CasADi::MX* x1);+CasADi::MX* CasADi__inner_prod_TIC_TIC_TIC(CasADi::MX* x0, CasADi::MX* x1){+ CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);+ CasADi::MX x1_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x1);++ return new CasADi::MX( CasADi::inner_prod(x0_, x1_) );+}+++// ================== function "CasADi::outer_prod'''" ===============+// cppName: "CasADi::outer_prod'''"+// cWrapperName: "CasADi__outer_prod_TIC_TIC_TIC"+// protoArgs: "(CasADi::MX* x0, CasADi::MX* x1)"+// params: [ConstRef (NonVec (CasadiClass MX)),ConstRef (NonVec (CasadiClass MX))]+// args: "(x0_, x1_)"+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__outer_prod_TIC_TIC_TIC(CasADi::MX* x0, CasADi::MX* x1)"+// call: "CasADi::outer_prod(x0_, x1_)"+extern "C"+ CasADi::MX* CasADi__outer_prod_TIC_TIC_TIC(CasADi::MX* x0, CasADi::MX* x1);+CasADi::MX* CasADi__outer_prod_TIC_TIC_TIC(CasADi::MX* x0, CasADi::MX* x1){+ CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);+ CasADi::MX x1_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x1);++ return new CasADi::MX( CasADi::outer_prod(x0_, x1_) );+}+++// ================== function "CasADi::if_else'" ===============+// cppName: "CasADi::if_else'"+// cWrapperName: "CasADi__if_else_TIC"+// protoArgs: "(CasADi::MX* x0, CasADi::MX* x1, CasADi::MX* x2)"+// params: [ConstRef (NonVec (CasadiClass MX)),ConstRef (NonVec (CasadiClass MX)),ConstRef (NonVec (CasadiClass MX))]+// args: "(x0_, x1_, x2_)"+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__if_else_TIC(CasADi::MX* x0, CasADi::MX* x1, CasADi::MX* x2)"+// call: "CasADi::if_else(x0_, x1_, x2_)"+extern "C"+ CasADi::MX* CasADi__if_else_TIC(CasADi::MX* x0, CasADi::MX* x1, CasADi::MX* x2);+CasADi::MX* CasADi__if_else_TIC(CasADi::MX* x0, CasADi::MX* x1, CasADi::MX* x2){+ CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);+ CasADi::MX x1_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x1);+ CasADi::MX x2_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x2);++ return new CasADi::MX( CasADi::if_else(x0_, x1_, x2_) );+}+++// ================== function "CasADi::reshape'''''''" ===============+// cppName: "CasADi::reshape'''''''"+// cWrapperName: "CasADi__reshape_TIC_TIC_TIC_TIC_TIC_TIC_TIC"+// protoArgs: "(CasADi::MX* x0, CasADi::CRSSparsity* x1)"+// params: [ConstRef (NonVec (CasadiClass MX)),ConstRef (NonVec (CasadiClass CRSSparsity))]+// args: "(x0_, x1_)"+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__reshape_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0, CasADi::CRSSparsity* x1)"+// call: "CasADi::reshape(x0_, x1_)"+extern "C"+ CasADi::MX* CasADi__reshape_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0, CasADi::CRSSparsity* x1);+CasADi::MX* CasADi__reshape_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0, CasADi::CRSSparsity* x1){+ CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);+ CasADi::CRSSparsity x1_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x1);++ return new CasADi::MX( CasADi::reshape(x0_, x1_) );+}+++// ================== function "CasADi::vec''''" ===============+// cppName: "CasADi::vec''''"+// cWrapperName: "CasADi__vec_TIC_TIC_TIC_TIC"+// protoArgs: "(CasADi::MX* x0)"+// params: [ConstRef (NonVec (CasadiClass MX))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__vec_TIC_TIC_TIC_TIC(CasADi::MX* x0)"+// call: "CasADi::vec(x0_)"+extern "C"+ CasADi::MX* CasADi__vec_TIC_TIC_TIC_TIC(CasADi::MX* x0);+CasADi::MX* CasADi__vec_TIC_TIC_TIC_TIC(CasADi::MX* x0){+ CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);++ return new CasADi::MX( CasADi::vec(x0_) );+}+++// ================== function "CasADi::flatten'''" ===============+// cppName: "CasADi::flatten'''"+// cWrapperName: "CasADi__flatten_TIC_TIC_TIC"+// protoArgs: "(CasADi::MX* x0)"+// params: [ConstRef (NonVec (CasadiClass MX))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__flatten_TIC_TIC_TIC(CasADi::MX* x0)"+// call: "CasADi::flatten(x0_)"+extern "C"+ CasADi::MX* CasADi__flatten_TIC_TIC_TIC(CasADi::MX* x0);+CasADi::MX* CasADi__flatten_TIC_TIC_TIC(CasADi::MX* x0){+ CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);++ return new CasADi::MX( CasADi::flatten(x0_) );+}+++// ================== function "CasADi::vecNZ'''" ===============+// cppName: "CasADi::vecNZ'''"+// cWrapperName: "CasADi__vecNZ_TIC_TIC_TIC"+// protoArgs: "(CasADi::MX* x0)"+// params: [ConstRef (NonVec (CasadiClass MX))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__vecNZ_TIC_TIC_TIC(CasADi::MX* x0)"+// call: "CasADi::vecNZ(x0_)"+extern "C"+ CasADi::MX* CasADi__vecNZ_TIC_TIC_TIC(CasADi::MX* x0);+CasADi::MX* CasADi__vecNZ_TIC_TIC_TIC(CasADi::MX* x0){+ CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);++ return new CasADi::MX( CasADi::vecNZ(x0_) );+}+++// ================== function "CasADi::flattenNZ'''" ===============+// cppName: "CasADi::flattenNZ'''"+// cWrapperName: "CasADi__flattenNZ_TIC_TIC_TIC"+// protoArgs: "(CasADi::MX* x0)"+// params: [ConstRef (NonVec (CasadiClass MX))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__flattenNZ_TIC_TIC_TIC(CasADi::MX* x0)"+// call: "CasADi::flattenNZ(x0_)"+extern "C"+ CasADi::MX* CasADi__flattenNZ_TIC_TIC_TIC(CasADi::MX* x0);+CasADi::MX* CasADi__flattenNZ_TIC_TIC_TIC(CasADi::MX* x0){+ CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);++ return new CasADi::MX( CasADi::flattenNZ(x0_) );+}+++// ================== function "CasADi::unite'''" ===============+// cppName: "CasADi::unite'''"+// cWrapperName: "CasADi__unite_TIC_TIC_TIC"+// protoArgs: "(CasADi::MX* x0, CasADi::MX* x1)"+// params: [ConstRef (NonVec (CasadiClass MX)),ConstRef (NonVec (CasadiClass MX))]+// args: "(x0_, x1_)"+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__unite_TIC_TIC_TIC(CasADi::MX* x0, CasADi::MX* x1)"+// call: "CasADi::unite(x0_, x1_)"+extern "C"+ CasADi::MX* CasADi__unite_TIC_TIC_TIC(CasADi::MX* x0, CasADi::MX* x1);+CasADi::MX* CasADi__unite_TIC_TIC_TIC(CasADi::MX* x0, CasADi::MX* x1){+ CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);+ CasADi::MX x1_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x1);++ return new CasADi::MX( CasADi::unite(x0_, x1_) );+}+++// ================== function "CasADi::isSymbolic'" ===============+// cppName: "CasADi::isSymbolic'"+// cWrapperName: "CasADi__isSymbolic_TIC"+// protoArgs: "(CasADi::MX* x0)"+// params: [ConstRef (NonVec (CasadiClass MX))]+// args: "(x0_)"+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__isSymbolic_TIC(CasADi::MX* x0)"+// call: "CasADi::isSymbolic(x0_)"+extern "C"+ bool* CasADi__isSymbolic_TIC(CasADi::MX* x0);+bool* CasADi__isSymbolic_TIC(CasADi::MX* x0){+ CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);++ return new bool( CasADi::isSymbolic(x0_) );+}+++// ================== function "CasADi::isSymbolicSparse'" ===============+// cppName: "CasADi::isSymbolicSparse'"+// cWrapperName: "CasADi__isSymbolicSparse_TIC"+// protoArgs: "(CasADi::MX* x0)"+// params: [ConstRef (NonVec (CasadiClass MX))]+// args: "(x0_)"+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__isSymbolicSparse_TIC(CasADi::MX* x0)"+// call: "CasADi::isSymbolicSparse(x0_)"+extern "C"+ bool* CasADi__isSymbolicSparse_TIC(CasADi::MX* x0);+bool* CasADi__isSymbolicSparse_TIC(CasADi::MX* x0){+ CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);++ return new bool( CasADi::isSymbolicSparse(x0_) );+}+++// ================== function "CasADi::isIdentity'''" ===============+// cppName: "CasADi::isIdentity'''"+// cWrapperName: "CasADi__isIdentity_TIC_TIC_TIC"+// protoArgs: "(CasADi::MX* x0)"+// params: [ConstRef (NonVec (CasadiClass MX))]+// args: "(x0_)"+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__isIdentity_TIC_TIC_TIC(CasADi::MX* x0)"+// call: "CasADi::isIdentity(x0_)"+extern "C"+ bool* CasADi__isIdentity_TIC_TIC_TIC(CasADi::MX* x0);+bool* CasADi__isIdentity_TIC_TIC_TIC(CasADi::MX* x0){+ CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);++ return new bool( CasADi::isIdentity(x0_) );+}+++// ================== function "CasADi::isZero'''" ===============+// cppName: "CasADi::isZero'''"+// cWrapperName: "CasADi__isZero_TIC_TIC_TIC"+// protoArgs: "(CasADi::MX* x0)"+// params: [ConstRef (NonVec (CasadiClass MX))]+// args: "(x0_)"+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__isZero_TIC_TIC_TIC(CasADi::MX* x0)"+// call: "CasADi::isZero(x0_)"+extern "C"+ bool* CasADi__isZero_TIC_TIC_TIC(CasADi::MX* x0);+bool* CasADi__isZero_TIC_TIC_TIC(CasADi::MX* x0){+ CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);++ return new bool( CasADi::isZero(x0_) );+}+++// ================== function "CasADi::isOne'''" ===============+// cppName: "CasADi::isOne'''"+// cWrapperName: "CasADi__isOne_TIC_TIC_TIC"+// protoArgs: "(CasADi::MX* x0)"+// params: [ConstRef (NonVec (CasadiClass MX))]+// args: "(x0_)"+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__isOne_TIC_TIC_TIC(CasADi::MX* x0)"+// call: "CasADi::isOne(x0_)"+extern "C"+ bool* CasADi__isOne_TIC_TIC_TIC(CasADi::MX* x0);+bool* CasADi__isOne_TIC_TIC_TIC(CasADi::MX* x0){+ CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);++ return new bool( CasADi::isOne(x0_) );+}+++// ================== function "CasADi::simplify''" ===============+// cppName: "CasADi::simplify''"+// cWrapperName: "CasADi__simplify_TIC_TIC"+// protoArgs: "(CasADi::MX* x0)"+// params: [Ref (NonVec (CasadiClass MX))]+// args: "(x0_)"+// cWrapperRetType: "void"+// proto: "void CasADi__simplify_TIC_TIC(CasADi::MX* x0)"+// call: "CasADi::simplify(x0_)"+extern "C"+ void CasADi__simplify_TIC_TIC(CasADi::MX* x0);+void CasADi__simplify_TIC_TIC(CasADi::MX* x0){+ CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);++ return CasADi::simplify(x0_);+}+++// ================== function "CasADi::isTranspose" ===============+// cppName: "CasADi::isTranspose"+// cWrapperName: "CasADi__isTranspose"+// protoArgs: "(CasADi::MX* x0)"+// params: [ConstRef (NonVec (CasadiClass MX))]+// args: "(x0_)"+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__isTranspose(CasADi::MX* x0)"+// call: "CasADi::isTranspose(x0_)"+extern "C"+ bool* CasADi__isTranspose(CasADi::MX* x0);+bool* CasADi__isTranspose(CasADi::MX* x0){+ CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);++ return new bool( CasADi::isTranspose(x0_) );+}+++// ================== function "CasADi::isMinusOne'''" ===============+// cppName: "CasADi::isMinusOne'''"+// cWrapperName: "CasADi__isMinusOne_TIC_TIC_TIC"+// protoArgs: "(CasADi::MX* x0)"+// params: [ConstRef (NonVec (CasadiClass MX))]+// args: "(x0_)"+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__isMinusOne_TIC_TIC_TIC(CasADi::MX* x0)"+// call: "CasADi::isMinusOne(x0_)"+extern "C"+ bool* CasADi__isMinusOne_TIC_TIC_TIC(CasADi::MX* x0);+bool* CasADi__isMinusOne_TIC_TIC_TIC(CasADi::MX* x0){+ CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);++ return new bool( CasADi::isMinusOne(x0_) );+}+++// ================== function "CasADi::isVector'''" ===============+// cppName: "CasADi::isVector'''"+// cWrapperName: "CasADi__isVector_TIC_TIC_TIC"+// protoArgs: "(CasADi::MX* x0)"+// params: [ConstRef (NonVec (CasadiClass MX))]+// args: "(x0_)"+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__isVector_TIC_TIC_TIC(CasADi::MX* x0)"+// call: "CasADi::isVector(x0_)"+extern "C"+ bool* CasADi__isVector_TIC_TIC_TIC(CasADi::MX* x0);+bool* CasADi__isVector_TIC_TIC_TIC(CasADi::MX* x0){+ CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);++ return new bool( CasADi::isVector(x0_) );+}+++// ================== function "CasADi::isDense'''" ===============+// cppName: "CasADi::isDense'''"+// cWrapperName: "CasADi__isDense_TIC_TIC_TIC"+// protoArgs: "(CasADi::MX* x0)"+// params: [ConstRef (NonVec (CasadiClass MX))]+// args: "(x0_)"+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__isDense_TIC_TIC_TIC(CasADi::MX* x0)"+// call: "CasADi::isDense(x0_)"+extern "C"+ bool* CasADi__isDense_TIC_TIC_TIC(CasADi::MX* x0);+bool* CasADi__isDense_TIC_TIC_TIC(CasADi::MX* x0){+ CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);++ return new bool( CasADi::isDense(x0_) );+}+++// ================== function "CasADi::isRegular''''''" ===============+// cppName: "CasADi::isRegular''''''"+// cWrapperName: "CasADi__isRegular_TIC_TIC_TIC_TIC_TIC_TIC"+// protoArgs: "(CasADi::MX* x0)"+// params: [ConstRef (NonVec (CasadiClass MX))]+// args: "(x0_)"+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__isRegular_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0)"+// call: "CasADi::isRegular(x0_)"+extern "C"+ bool* CasADi__isRegular_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0);+bool* CasADi__isRegular_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0){+ CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);++ return new bool( CasADi::isRegular(x0_) );+}+++// ================== function "CasADi::trace'''" ===============+// cppName: "CasADi::trace'''"+// cWrapperName: "CasADi__trace_TIC_TIC_TIC"+// protoArgs: "(CasADi::MX* x0)"+// params: [ConstRef (NonVec (CasadiClass MX))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__trace_TIC_TIC_TIC(CasADi::MX* x0)"+// call: "CasADi::trace(x0_)"+extern "C"+ CasADi::MX* CasADi__trace_TIC_TIC_TIC(CasADi::MX* x0);+CasADi::MX* CasADi__trace_TIC_TIC_TIC(CasADi::MX* x0){+ CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);++ return new CasADi::MX( CasADi::trace(x0_) );+}+++// ================== function "CasADi::repmat'''" ===============+// cppName: "CasADi::repmat'''"+// cWrapperName: "CasADi__repmat_TIC_TIC_TIC"+// protoArgs: "(CasADi::MX* x0, int x1, int x2)"+// params: [ConstRef (NonVec (CasadiClass MX)),Val (NonVec CInt),Val (NonVec CInt)]+// args: "(x0_, x1_, x2_)"+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__repmat_TIC_TIC_TIC(CasADi::MX* x0, int x1, int x2)"+// call: "CasADi::repmat(x0_, x1_, x2_)"+extern "C"+ CasADi::MX* CasADi__repmat_TIC_TIC_TIC(CasADi::MX* x0, int x1, int x2);+CasADi::MX* CasADi__repmat_TIC_TIC_TIC(CasADi::MX* x0, int x1, int x2){+ CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);+ int x2_ = Marshaling<int,int>::marshal(x2);++ return new CasADi::MX( CasADi::repmat(x0_, x1_, x2_) );+}+++// ================== function "CasADi::makeDense'''" ===============+// cppName: "CasADi::makeDense'''"+// cWrapperName: "CasADi__makeDense_TIC_TIC_TIC"+// protoArgs: "(CasADi::MX* x0)"+// params: [Ref (NonVec (CasadiClass MX))]+// args: "(x0_)"+// cWrapperRetType: "void"+// proto: "void CasADi__makeDense_TIC_TIC_TIC(CasADi::MX* x0)"+// call: "CasADi::makeDense(x0_)"+extern "C"+ void CasADi__makeDense_TIC_TIC_TIC(CasADi::MX* x0);+void CasADi__makeDense_TIC_TIC_TIC(CasADi::MX* x0){+ CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);++ return CasADi::makeDense(x0_);+}+++// ================== function "CasADi::densify'''" ===============+// cppName: "CasADi::densify'''"+// cWrapperName: "CasADi__densify_TIC_TIC_TIC"+// protoArgs: "(CasADi::MX* x0)"+// params: [ConstRef (NonVec (CasadiClass MX))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__densify_TIC_TIC_TIC(CasADi::MX* x0)"+// call: "CasADi::densify(x0_)"+extern "C"+ CasADi::MX* CasADi__densify_TIC_TIC_TIC(CasADi::MX* x0);+CasADi::MX* CasADi__densify_TIC_TIC_TIC(CasADi::MX* x0){+ CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);++ return new CasADi::MX( CasADi::densify(x0_) );+}+++// ================== function "CasADi::full'''" ===============+// cppName: "CasADi::full'''"+// cWrapperName: "CasADi__full_TIC_TIC_TIC"+// protoArgs: "(CasADi::MX* x0)"+// params: [ConstRef (NonVec (CasadiClass MX))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__full_TIC_TIC_TIC(CasADi::MX* x0)"+// call: "CasADi::full(x0_)"+extern "C"+ CasADi::MX* CasADi__full_TIC_TIC_TIC(CasADi::MX* x0);+CasADi::MX* CasADi__full_TIC_TIC_TIC(CasADi::MX* x0){+ CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);++ return new CasADi::MX( CasADi::full(x0_) );+}+++// ================== function "CasADi::createParent" ===============+// cppName: "CasADi::createParent"+// cWrapperName: "CasADi__createParent"+// protoArgs: "(std::vector<CasADi::MX* >* x0)"+// params: [Ref (Vec (NonVec (CasadiClass MX)))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__createParent(std::vector<CasADi::MX* >* x0)"+// call: "CasADi::createParent(x0_)"+extern "C"+ CasADi::MX* CasADi__createParent(std::vector<CasADi::MX* >* x0);+CasADi::MX* CasADi__createParent(std::vector<CasADi::MX* >* x0){+ std::vector<CasADi::MX > x0_ = Marshaling<std::vector<CasADi::MX >,std::vector<CasADi::MX* >*>::marshal(x0);++ return new CasADi::MX( CasADi::createParent(x0_) );+}+++// ================== function "CasADi::countNodes'" ===============+// cppName: "CasADi::countNodes'"+// cWrapperName: "CasADi__countNodes_TIC"+// protoArgs: "(CasADi::MX* x0)"+// params: [ConstRef (NonVec (CasadiClass MX))]+// args: "(x0_)"+// cWrapperRetType: "int"+// proto: "int CasADi__countNodes_TIC(CasADi::MX* x0)"+// call: "CasADi::countNodes(x0_)"+extern "C"+ int CasADi__countNodes_TIC(CasADi::MX* x0);+int CasADi__countNodes_TIC(CasADi::MX* x0){+ CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);++ return CasADi::countNodes(x0_);+}+++// ================== function "CasADi::diag'''" ===============+// cppName: "CasADi::diag'''"+// cWrapperName: "CasADi__diag_TIC_TIC_TIC"+// protoArgs: "(CasADi::MX* x0)"+// params: [ConstRef (NonVec (CasadiClass MX))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__diag_TIC_TIC_TIC(CasADi::MX* x0)"+// call: "CasADi::diag(x0_)"+extern "C"+ CasADi::MX* CasADi__diag_TIC_TIC_TIC(CasADi::MX* x0);+CasADi::MX* CasADi__diag_TIC_TIC_TIC(CasADi::MX* x0){+ CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);++ return new CasADi::MX( CasADi::diag(x0_) );+}+++// ================== function "CasADi::blkdiag''''" ===============+// cppName: "CasADi::blkdiag''''"+// cWrapperName: "CasADi__blkdiag_TIC_TIC_TIC_TIC"+// protoArgs: "(std::vector<CasADi::MX* > * x0)"+// params: [ConstRef (Vec (NonVec (CasadiClass MX)))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__blkdiag_TIC_TIC_TIC_TIC(std::vector<CasADi::MX* > * x0)"+// call: "CasADi::blkdiag(x0_)"+extern "C"+ CasADi::MX* CasADi__blkdiag_TIC_TIC_TIC_TIC(std::vector<CasADi::MX* > * x0);+CasADi::MX* CasADi__blkdiag_TIC_TIC_TIC_TIC(std::vector<CasADi::MX* > * x0){+ std::vector<CasADi::MX > x0_ = Marshaling<std::vector<CasADi::MX >,std::vector<CasADi::MX* > *>::marshal(x0);++ return new CasADi::MX( CasADi::blkdiag(x0_) );+}+++// ================== function "CasADi::sumRows'''" ===============+// cppName: "CasADi::sumRows'''"+// cWrapperName: "CasADi__sumRows_TIC_TIC_TIC"+// protoArgs: "(CasADi::MX* x0)"+// params: [ConstRef (NonVec (CasadiClass MX))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__sumRows_TIC_TIC_TIC(CasADi::MX* x0)"+// call: "CasADi::sumRows(x0_)"+extern "C"+ CasADi::MX* CasADi__sumRows_TIC_TIC_TIC(CasADi::MX* x0);+CasADi::MX* CasADi__sumRows_TIC_TIC_TIC(CasADi::MX* x0){+ CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);++ return new CasADi::MX( CasADi::sumRows(x0_) );+}+++// ================== function "CasADi::sumCols'''" ===============+// cppName: "CasADi::sumCols'''"+// cWrapperName: "CasADi__sumCols_TIC_TIC_TIC"+// protoArgs: "(CasADi::MX* x0)"+// params: [ConstRef (NonVec (CasadiClass MX))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__sumCols_TIC_TIC_TIC(CasADi::MX* x0)"+// call: "CasADi::sumCols(x0_)"+extern "C"+ CasADi::MX* CasADi__sumCols_TIC_TIC_TIC(CasADi::MX* x0);+CasADi::MX* CasADi__sumCols_TIC_TIC_TIC(CasADi::MX* x0){+ CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);++ return new CasADi::MX( CasADi::sumCols(x0_) );+}+++// ================== function "CasADi::sumAll'''" ===============+// cppName: "CasADi::sumAll'''"+// cWrapperName: "CasADi__sumAll_TIC_TIC_TIC"+// protoArgs: "(CasADi::MX* x0)"+// params: [ConstRef (NonVec (CasadiClass MX))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__sumAll_TIC_TIC_TIC(CasADi::MX* x0)"+// call: "CasADi::sumAll(x0_)"+extern "C"+ CasADi::MX* CasADi__sumAll_TIC_TIC_TIC(CasADi::MX* x0);+CasADi::MX* CasADi__sumAll_TIC_TIC_TIC(CasADi::MX* x0){+ CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);++ return new CasADi::MX( CasADi::sumAll(x0_) );+}+++// ================== function "CasADi::polyval'''" ===============+// cppName: "CasADi::polyval'''"+// cWrapperName: "CasADi__polyval_TIC_TIC_TIC"+// protoArgs: "(CasADi::MX* x0, CasADi::MX* x1)"+// params: [ConstRef (NonVec (CasadiClass MX)),ConstRef (NonVec (CasadiClass MX))]+// args: "(x0_, x1_)"+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__polyval_TIC_TIC_TIC(CasADi::MX* x0, CasADi::MX* x1)"+// call: "CasADi::polyval(x0_, x1_)"+extern "C"+ CasADi::MX* CasADi__polyval_TIC_TIC_TIC(CasADi::MX* x0, CasADi::MX* x1);+CasADi::MX* CasADi__polyval_TIC_TIC_TIC(CasADi::MX* x0, CasADi::MX* x1){+ CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);+ CasADi::MX x1_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x1);++ return new CasADi::MX( CasADi::polyval(x0_, x1_) );+}+++// ================== function "CasADi::msym" ===============+// cppName: "CasADi::msym"+// cWrapperName: "CasADi__msym"+// protoArgs: "(std::string* x0, int x1, int x2)"+// params: [ConstRef (NonVec StdString),Val (NonVec CInt),Val (NonVec CInt)]+// args: "(x0_, x1_, x2_)"+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__msym(std::string* x0, int x1, int x2)"+// call: "CasADi::msym(x0_, x1_, x2_)"+extern "C"+ CasADi::MX* CasADi__msym(std::string* x0, int x1, int x2);+CasADi::MX* CasADi__msym(std::string* x0, int x1, int x2){+ std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);+ int x2_ = Marshaling<int,int>::marshal(x2);++ return new CasADi::MX( CasADi::msym(x0_, x1_, x2_) );+}+++// ================== function "CasADi::msym'" ===============+// cppName: "CasADi::msym'"+// cWrapperName: "CasADi__msym_TIC"+// protoArgs: "(std::string* x0, int x1)"+// params: [ConstRef (NonVec StdString),Val (NonVec CInt)]+// args: "(x0_, x1_)"+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__msym_TIC(std::string* x0, int x1)"+// call: "CasADi::msym(x0_, x1_)"+extern "C"+ CasADi::MX* CasADi__msym_TIC(std::string* x0, int x1);+CasADi::MX* CasADi__msym_TIC(std::string* x0, int x1){+ std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);++ return new CasADi::MX( CasADi::msym(x0_, x1_) );+}+++// ================== function "CasADi::msym''" ===============+// cppName: "CasADi::msym''"+// cWrapperName: "CasADi__msym_TIC_TIC"+// protoArgs: "(std::string* x0)"+// params: [ConstRef (NonVec StdString)]+// args: "(x0_)"+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__msym_TIC_TIC(std::string* x0)"+// call: "CasADi::msym(x0_)"+extern "C"+ CasADi::MX* CasADi__msym_TIC_TIC(std::string* x0);+CasADi::MX* CasADi__msym_TIC_TIC(std::string* x0){+ std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);++ return new CasADi::MX( CasADi::msym(x0_) );+}+++// ================== function "CasADi::msym'''" ===============+// cppName: "CasADi::msym'''"+// cWrapperName: "CasADi__msym_TIC_TIC_TIC"+// protoArgs: "(CasADi::Matrix< double >* x0)"+// params: [ConstRef (NonVec (CasadiClass DMatrix))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__msym_TIC_TIC_TIC(CasADi::Matrix< double >* x0)"+// call: "CasADi::msym(x0_)"+extern "C"+ CasADi::MX* CasADi__msym_TIC_TIC_TIC(CasADi::Matrix< double >* x0);+CasADi::MX* CasADi__msym_TIC_TIC_TIC(CasADi::Matrix< double >* x0){+ CasADi::Matrix< double > x0_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x0);++ return new CasADi::MX( CasADi::msym(x0_) );+}+++// ================== function "CasADi::msym''''" ===============+// cppName: "CasADi::msym''''"+// cWrapperName: "CasADi__msym_TIC_TIC_TIC_TIC"+// protoArgs: "(std::string* x0, CasADi::CRSSparsity* x1)"+// params: [ConstRef (NonVec StdString),ConstRef (NonVec (CasadiClass CRSSparsity))]+// args: "(x0_, x1_)"+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__msym_TIC_TIC_TIC_TIC(std::string* x0, CasADi::CRSSparsity* x1)"+// call: "CasADi::msym(x0_, x1_)"+extern "C"+ CasADi::MX* CasADi__msym_TIC_TIC_TIC_TIC(std::string* x0, CasADi::CRSSparsity* x1);+CasADi::MX* CasADi__msym_TIC_TIC_TIC_TIC(std::string* x0, CasADi::CRSSparsity* x1){+ std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);+ CasADi::CRSSparsity x1_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x1);++ return new CasADi::MX( CasADi::msym(x0_, x1_) );+}+++// ================== function "CasADi::msym'''''" ===============+// cppName: "CasADi::msym'''''"+// cWrapperName: "CasADi__msym_TIC_TIC_TIC_TIC_TIC"+// protoArgs: "(std::string* x0, CasADi::CRSSparsity* x1, int x2)"+// params: [ConstRef (NonVec StdString),ConstRef (NonVec (CasadiClass CRSSparsity)),Val (NonVec CInt)]+// args: "(x0_, x1_, x2_)"+// cWrapperRetType: "std::vector<CasADi::MX >*"+// proto: "std::vector<CasADi::MX >* CasADi__msym_TIC_TIC_TIC_TIC_TIC(std::string* x0, CasADi::CRSSparsity* x1, int x2)"+// call: "CasADi::msym(x0_, x1_, x2_)"+extern "C"+ std::vector<CasADi::MX >* CasADi__msym_TIC_TIC_TIC_TIC_TIC(std::string* x0, CasADi::CRSSparsity* x1, int x2);+std::vector<CasADi::MX >* CasADi__msym_TIC_TIC_TIC_TIC_TIC(std::string* x0, CasADi::CRSSparsity* x1, int x2){+ std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);+ CasADi::CRSSparsity x1_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x1);+ int x2_ = Marshaling<int,int>::marshal(x2);++ return new std::vector<CasADi::MX >( CasADi::msym(x0_, x1_, x2_) );+}+++// ================== function "CasADi::msym''''''" ===============+// cppName: "CasADi::msym''''''"+// cWrapperName: "CasADi__msym_TIC_TIC_TIC_TIC_TIC_TIC"+// protoArgs: "(std::string* x0, int x1, int x2, int x3)"+// params: [ConstRef (NonVec StdString),Val (NonVec CInt),Val (NonVec CInt),Val (NonVec CInt)]+// args: "(x0_, x1_, x2_, x3_)"+// cWrapperRetType: "std::vector<CasADi::MX >*"+// proto: "std::vector<CasADi::MX >* CasADi__msym_TIC_TIC_TIC_TIC_TIC_TIC(std::string* x0, int x1, int x2, int x3)"+// call: "CasADi::msym(x0_, x1_, x2_, x3_)"+extern "C"+ std::vector<CasADi::MX >* CasADi__msym_TIC_TIC_TIC_TIC_TIC_TIC(std::string* x0, int x1, int x2, int x3);+std::vector<CasADi::MX >* CasADi__msym_TIC_TIC_TIC_TIC_TIC_TIC(std::string* x0, int x1, int x2, int x3){+ std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);+ int x2_ = Marshaling<int,int>::marshal(x2);+ int x3_ = Marshaling<int,int>::marshal(x3);++ return new std::vector<CasADi::MX >( CasADi::msym(x0_, x1_, x2_, x3_) );+}+++// ================== function "CasADi::msym'''''''" ===============+// cppName: "CasADi::msym'''''''"+// cWrapperName: "CasADi__msym_TIC_TIC_TIC_TIC_TIC_TIC_TIC"+// protoArgs: "(std::string* x0, CasADi::CRSSparsity* x1, int x2, int x3)"+// params: [ConstRef (NonVec StdString),ConstRef (NonVec (CasadiClass CRSSparsity)),Val (NonVec CInt),Val (NonVec CInt)]+// args: "(x0_, x1_, x2_, x3_)"+// cWrapperRetType: "std::vector<std::vector<CasADi::MX > >*"+// proto: "std::vector<std::vector<CasADi::MX > >* CasADi__msym_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::string* x0, CasADi::CRSSparsity* x1, int x2, int x3)"+// call: "CasADi::msym(x0_, x1_, x2_, x3_)"+extern "C"+ std::vector<std::vector<CasADi::MX > >* CasADi__msym_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::string* x0, CasADi::CRSSparsity* x1, int x2, int x3);+std::vector<std::vector<CasADi::MX > >* CasADi__msym_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::string* x0, CasADi::CRSSparsity* x1, int x2, int x3){+ std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);+ CasADi::CRSSparsity x1_ = Marshaling<CasADi::CRSSparsity,CasADi::CRSSparsity*>::marshal(x1);+ int x2_ = Marshaling<int,int>::marshal(x2);+ int x3_ = Marshaling<int,int>::marshal(x3);++ return new std::vector<std::vector<CasADi::MX > >( CasADi::msym(x0_, x1_, x2_, x3_) );+}+++// ================== function "CasADi::msym''''''''" ===============+// cppName: "CasADi::msym''''''''"+// cWrapperName: "CasADi__msym_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"+// protoArgs: "(std::string* x0, int x1, int x2, int x3, int x4)"+// params: [ConstRef (NonVec StdString),Val (NonVec CInt),Val (NonVec CInt),Val (NonVec CInt),Val (NonVec CInt)]+// args: "(x0_, x1_, x2_, x3_, x4_)"+// cWrapperRetType: "std::vector<std::vector<CasADi::MX > >*"+// proto: "std::vector<std::vector<CasADi::MX > >* CasADi__msym_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::string* x0, int x1, int x2, int x3, int x4)"+// call: "CasADi::msym(x0_, x1_, x2_, x3_, x4_)"+extern "C"+ std::vector<std::vector<CasADi::MX > >* CasADi__msym_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::string* x0, int x1, int x2, int x3, int x4);+std::vector<std::vector<CasADi::MX > >* CasADi__msym_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::string* x0, int x1, int x2, int x3, int x4){+ std::string x0_ = Marshaling<std::string,std::string*>::marshal(x0);+ int x1_ = Marshaling<int,int>::marshal(x1);+ int x2_ = Marshaling<int,int>::marshal(x2);+ int x3_ = Marshaling<int,int>::marshal(x3);+ int x4_ = Marshaling<int,int>::marshal(x4);++ return new std::vector<std::vector<CasADi::MX > >( CasADi::msym(x0_, x1_, x2_, x3_, x4_) );+}+++// ================== function "CasADi::isEqual'''" ===============+// cppName: "CasADi::isEqual'''"+// cWrapperName: "CasADi__isEqual_TIC_TIC_TIC"+// protoArgs: "(CasADi::MX* x0, CasADi::MX* x1)"+// params: [ConstRef (NonVec (CasadiClass MX)),ConstRef (NonVec (CasadiClass MX))]+// args: "(x0_, x1_)"+// cWrapperRetType: "bool*"+// proto: "bool* CasADi__isEqual_TIC_TIC_TIC(CasADi::MX* x0, CasADi::MX* x1)"+// call: "CasADi::isEqual(x0_, x1_)"+extern "C"+ bool* CasADi__isEqual_TIC_TIC_TIC(CasADi::MX* x0, CasADi::MX* x1);+bool* CasADi__isEqual_TIC_TIC_TIC(CasADi::MX* x0, CasADi::MX* x1){+ CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);+ CasADi::MX x1_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x1);++ return new bool( CasADi::isEqual(x0_, x1_) );+}+++// ================== function "CasADi::getOperatorRepresentation'" ===============+// cppName: "CasADi::getOperatorRepresentation'"+// cWrapperName: "CasADi__getOperatorRepresentation_TIC"+// protoArgs: "(CasADi::MX* x0, std::vector<std::string* > * x1)"+// params: [ConstRef (NonVec (CasadiClass MX)),ConstRef (Vec (NonVec StdString))]+// args: "(x0_, x1_)"+// cWrapperRetType: "std::string*"+// proto: "std::string* CasADi__getOperatorRepresentation_TIC(CasADi::MX* x0, std::vector<std::string* > * x1)"+// call: "CasADi::getOperatorRepresentation(x0_, x1_)"+extern "C"+ std::string* CasADi__getOperatorRepresentation_TIC(CasADi::MX* x0, std::vector<std::string* > * x1);+std::string* CasADi__getOperatorRepresentation_TIC(CasADi::MX* x0, std::vector<std::string* > * x1){+ CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);+ std::vector<std::string > x1_ = Marshaling<std::vector<std::string >,std::vector<std::string* > *>::marshal(x1);++ return new std::string( CasADi::getOperatorRepresentation(x0_, x1_) );+}+++// ================== function "CasADi::substitute''" ===============+// cppName: "CasADi::substitute''"+// cWrapperName: "CasADi__substitute_TIC_TIC"+// protoArgs: "(CasADi::MX* x0, CasADi::MX* x1, CasADi::MX* x2)"+// params: [ConstRef (NonVec (CasadiClass MX)),ConstRef (NonVec (CasadiClass MX)),ConstRef (NonVec (CasadiClass MX))]+// args: "(x0_, x1_, x2_)"+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__substitute_TIC_TIC(CasADi::MX* x0, CasADi::MX* x1, CasADi::MX* x2)"+// call: "CasADi::substitute(x0_, x1_, x2_)"+extern "C"+ CasADi::MX* CasADi__substitute_TIC_TIC(CasADi::MX* x0, CasADi::MX* x1, CasADi::MX* x2);+CasADi::MX* CasADi__substitute_TIC_TIC(CasADi::MX* x0, CasADi::MX* x1, CasADi::MX* x2){+ CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);+ CasADi::MX x1_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x1);+ CasADi::MX x2_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x2);++ return new CasADi::MX( CasADi::substitute(x0_, x1_, x2_) );+}+++// ================== function "CasADi::substitute'''" ===============+// cppName: "CasADi::substitute'''"+// cWrapperName: "CasADi__substitute_TIC_TIC_TIC"+// protoArgs: "(std::vector<CasADi::MX* > * x0, std::vector<CasADi::MX* > * x1, std::vector<CasADi::MX* > * x2)"+// params: [ConstRef (Vec (NonVec (CasadiClass MX))),ConstRef (Vec (NonVec (CasadiClass MX))),ConstRef (Vec (NonVec (CasadiClass MX)))]+// args: "(x0_, x1_, x2_)"+// cWrapperRetType: "std::vector<CasADi::MX >*"+// proto: "std::vector<CasADi::MX >* CasADi__substitute_TIC_TIC_TIC(std::vector<CasADi::MX* > * x0, std::vector<CasADi::MX* > * x1, std::vector<CasADi::MX* > * x2)"+// call: "CasADi::substitute(x0_, x1_, x2_)"+extern "C"+ std::vector<CasADi::MX >* CasADi__substitute_TIC_TIC_TIC(std::vector<CasADi::MX* > * x0, std::vector<CasADi::MX* > * x1, std::vector<CasADi::MX* > * x2);+std::vector<CasADi::MX >* CasADi__substitute_TIC_TIC_TIC(std::vector<CasADi::MX* > * x0, std::vector<CasADi::MX* > * x1, std::vector<CasADi::MX* > * x2){+ std::vector<CasADi::MX > x0_ = Marshaling<std::vector<CasADi::MX >,std::vector<CasADi::MX* > *>::marshal(x0);+ std::vector<CasADi::MX > x1_ = Marshaling<std::vector<CasADi::MX >,std::vector<CasADi::MX* > *>::marshal(x1);+ std::vector<CasADi::MX > x2_ = Marshaling<std::vector<CasADi::MX >,std::vector<CasADi::MX* > *>::marshal(x2);++ return new std::vector<CasADi::MX >( CasADi::substitute(x0_, x1_, x2_) );+}+++// ================== function "CasADi::graph_substitute" ===============+// cppName: "CasADi::graph_substitute"+// cWrapperName: "CasADi__graph_substitute"+// protoArgs: "(CasADi::MX* x0, std::vector<CasADi::MX* > * x1, std::vector<CasADi::MX* > * x2)"+// params: [ConstRef (NonVec (CasadiClass MX)),ConstRef (Vec (NonVec (CasadiClass MX))),ConstRef (Vec (NonVec (CasadiClass MX)))]+// args: "(x0_, x1_, x2_)"+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__graph_substitute(CasADi::MX* x0, std::vector<CasADi::MX* > * x1, std::vector<CasADi::MX* > * x2)"+// call: "CasADi::graph_substitute(x0_, x1_, x2_)"+extern "C"+ CasADi::MX* CasADi__graph_substitute(CasADi::MX* x0, std::vector<CasADi::MX* > * x1, std::vector<CasADi::MX* > * x2);+CasADi::MX* CasADi__graph_substitute(CasADi::MX* x0, std::vector<CasADi::MX* > * x1, std::vector<CasADi::MX* > * x2){+ CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);+ std::vector<CasADi::MX > x1_ = Marshaling<std::vector<CasADi::MX >,std::vector<CasADi::MX* > *>::marshal(x1);+ std::vector<CasADi::MX > x2_ = Marshaling<std::vector<CasADi::MX >,std::vector<CasADi::MX* > *>::marshal(x2);++ return new CasADi::MX( CasADi::graph_substitute(x0_, x1_, x2_) );+}+++// ================== function "CasADi::graph_substitute'" ===============+// cppName: "CasADi::graph_substitute'"+// cWrapperName: "CasADi__graph_substitute_TIC"+// protoArgs: "(std::vector<CasADi::MX* > * x0, std::vector<CasADi::MX* > * x1, std::vector<CasADi::MX* > * x2)"+// params: [ConstRef (Vec (NonVec (CasadiClass MX))),ConstRef (Vec (NonVec (CasadiClass MX))),ConstRef (Vec (NonVec (CasadiClass MX)))]+// args: "(x0_, x1_, x2_)"+// cWrapperRetType: "std::vector<CasADi::MX >*"+// proto: "std::vector<CasADi::MX >* CasADi__graph_substitute_TIC(std::vector<CasADi::MX* > * x0, std::vector<CasADi::MX* > * x1, std::vector<CasADi::MX* > * x2)"+// call: "CasADi::graph_substitute(x0_, x1_, x2_)"+extern "C"+ std::vector<CasADi::MX >* CasADi__graph_substitute_TIC(std::vector<CasADi::MX* > * x0, std::vector<CasADi::MX* > * x1, std::vector<CasADi::MX* > * x2);+std::vector<CasADi::MX >* CasADi__graph_substitute_TIC(std::vector<CasADi::MX* > * x0, std::vector<CasADi::MX* > * x1, std::vector<CasADi::MX* > * x2){+ std::vector<CasADi::MX > x0_ = Marshaling<std::vector<CasADi::MX >,std::vector<CasADi::MX* > *>::marshal(x0);+ std::vector<CasADi::MX > x1_ = Marshaling<std::vector<CasADi::MX >,std::vector<CasADi::MX* > *>::marshal(x1);+ std::vector<CasADi::MX > x2_ = Marshaling<std::vector<CasADi::MX >,std::vector<CasADi::MX* > *>::marshal(x2);++ return new std::vector<CasADi::MX >( CasADi::graph_substitute(x0_, x1_, x2_) );+}+++// ================== function "CasADi::substituteInPlace''''''" ===============+// cppName: "CasADi::substituteInPlace''''''"+// cWrapperName: "CasADi__substituteInPlace_TIC_TIC_TIC_TIC_TIC_TIC"+// protoArgs: "(std::vector<CasADi::MX* > * x0, std::vector<CasADi::MX* >* x1, bool* x2)"+// params: [ConstRef (Vec (NonVec (CasadiClass MX))),Ref (Vec (NonVec (CasadiClass MX))),Val (NonVec CBool)]+// args: "(x0_, x1_, x2_)"+// cWrapperRetType: "void"+// proto: "void CasADi__substituteInPlace_TIC_TIC_TIC_TIC_TIC_TIC(std::vector<CasADi::MX* > * x0, std::vector<CasADi::MX* >* x1, bool* x2)"+// call: "CasADi::substituteInPlace(x0_, x1_, x2_)"+extern "C"+ void CasADi__substituteInPlace_TIC_TIC_TIC_TIC_TIC_TIC(std::vector<CasADi::MX* > * x0, std::vector<CasADi::MX* >* x1, bool* x2);+void CasADi__substituteInPlace_TIC_TIC_TIC_TIC_TIC_TIC(std::vector<CasADi::MX* > * x0, std::vector<CasADi::MX* >* x1, bool* x2){+ std::vector<CasADi::MX > x0_ = Marshaling<std::vector<CasADi::MX >,std::vector<CasADi::MX* > *>::marshal(x0);+ std::vector<CasADi::MX > x1_ = Marshaling<std::vector<CasADi::MX >,std::vector<CasADi::MX* >*>::marshal(x1);+ bool x2_ = Marshaling<bool,bool*>::marshal(x2);++ return CasADi::substituteInPlace(x0_, x1_, x2_);+}+++// ================== function "CasADi::substituteInPlace'''''''" ===============+// cppName: "CasADi::substituteInPlace'''''''"+// cWrapperName: "CasADi__substituteInPlace_TIC_TIC_TIC_TIC_TIC_TIC_TIC"+// protoArgs: "(std::vector<CasADi::MX* > * x0, std::vector<CasADi::MX* >* x1)"+// params: [ConstRef (Vec (NonVec (CasadiClass MX))),Ref (Vec (NonVec (CasadiClass MX)))]+// args: "(x0_, x1_)"+// cWrapperRetType: "void"+// proto: "void CasADi__substituteInPlace_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector<CasADi::MX* > * x0, std::vector<CasADi::MX* >* x1)"+// call: "CasADi::substituteInPlace(x0_, x1_)"+extern "C"+ void CasADi__substituteInPlace_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector<CasADi::MX* > * x0, std::vector<CasADi::MX* >* x1);+void CasADi__substituteInPlace_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector<CasADi::MX* > * x0, std::vector<CasADi::MX* >* x1){+ std::vector<CasADi::MX > x0_ = Marshaling<std::vector<CasADi::MX >,std::vector<CasADi::MX* > *>::marshal(x0);+ std::vector<CasADi::MX > x1_ = Marshaling<std::vector<CasADi::MX >,std::vector<CasADi::MX* >*>::marshal(x1);++ return CasADi::substituteInPlace(x0_, x1_);+}+++// ================== function "CasADi::substituteInPlace''''''''" ===============+// cppName: "CasADi::substituteInPlace''''''''"+// cWrapperName: "CasADi__substituteInPlace_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"+// protoArgs: "(std::vector<CasADi::MX* > * x0, std::vector<CasADi::MX* >* x1, std::vector<CasADi::MX* >* x2, bool* x3)"+// params: [ConstRef (Vec (NonVec (CasadiClass MX))),Ref (Vec (NonVec (CasadiClass MX))),Ref (Vec (NonVec (CasadiClass MX))),Val (NonVec CBool)]+// args: "(x0_, x1_, x2_, x3_)"+// cWrapperRetType: "void"+// proto: "void CasADi__substituteInPlace_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector<CasADi::MX* > * x0, std::vector<CasADi::MX* >* x1, std::vector<CasADi::MX* >* x2, bool* x3)"+// call: "CasADi::substituteInPlace(x0_, x1_, x2_, x3_)"+extern "C"+ void CasADi__substituteInPlace_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector<CasADi::MX* > * x0, std::vector<CasADi::MX* >* x1, std::vector<CasADi::MX* >* x2, bool* x3);+void CasADi__substituteInPlace_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector<CasADi::MX* > * x0, std::vector<CasADi::MX* >* x1, std::vector<CasADi::MX* >* x2, bool* x3){+ std::vector<CasADi::MX > x0_ = Marshaling<std::vector<CasADi::MX >,std::vector<CasADi::MX* > *>::marshal(x0);+ std::vector<CasADi::MX > x1_ = Marshaling<std::vector<CasADi::MX >,std::vector<CasADi::MX* >*>::marshal(x1);+ std::vector<CasADi::MX > x2_ = Marshaling<std::vector<CasADi::MX >,std::vector<CasADi::MX* >*>::marshal(x2);+ bool x3_ = Marshaling<bool,bool*>::marshal(x3);++ return CasADi::substituteInPlace(x0_, x1_, x2_, x3_);+}+++// ================== function "CasADi::substituteInPlace'''''''''" ===============+// cppName: "CasADi::substituteInPlace'''''''''"+// cWrapperName: "CasADi__substituteInPlace_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC"+// protoArgs: "(std::vector<CasADi::MX* > * x0, std::vector<CasADi::MX* >* x1, std::vector<CasADi::MX* >* x2)"+// params: [ConstRef (Vec (NonVec (CasadiClass MX))),Ref (Vec (NonVec (CasadiClass MX))),Ref (Vec (NonVec (CasadiClass MX)))]+// args: "(x0_, x1_, x2_)"+// cWrapperRetType: "void"+// proto: "void CasADi__substituteInPlace_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector<CasADi::MX* > * x0, std::vector<CasADi::MX* >* x1, std::vector<CasADi::MX* >* x2)"+// call: "CasADi::substituteInPlace(x0_, x1_, x2_)"+extern "C"+ void CasADi__substituteInPlace_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector<CasADi::MX* > * x0, std::vector<CasADi::MX* >* x1, std::vector<CasADi::MX* >* x2);+void CasADi__substituteInPlace_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector<CasADi::MX* > * x0, std::vector<CasADi::MX* >* x1, std::vector<CasADi::MX* >* x2){+ std::vector<CasADi::MX > x0_ = Marshaling<std::vector<CasADi::MX >,std::vector<CasADi::MX* > *>::marshal(x0);+ std::vector<CasADi::MX > x1_ = Marshaling<std::vector<CasADi::MX >,std::vector<CasADi::MX* >*>::marshal(x1);+ std::vector<CasADi::MX > x2_ = Marshaling<std::vector<CasADi::MX >,std::vector<CasADi::MX* >*>::marshal(x2);++ return CasADi::substituteInPlace(x0_, x1_, x2_);+}+++// ================== function "CasADi::extractShared'''" ===============+// cppName: "CasADi::extractShared'''"+// cWrapperName: "CasADi__extractShared_TIC_TIC_TIC"+// protoArgs: "(std::vector<CasADi::MX* >* x0, std::vector<CasADi::MX* >* x1, std::vector<CasADi::MX* >* x2, std::string* x3, std::string* x4)"+// params: [Ref (Vec (NonVec (CasadiClass MX))),Ref (Vec (NonVec (CasadiClass MX))),Ref (Vec (NonVec (CasadiClass MX))),ConstRef (NonVec StdString),ConstRef (NonVec StdString)]+// args: "(x0_, x1_, x2_, x3_, x4_)"+// cWrapperRetType: "void"+// proto: "void CasADi__extractShared_TIC_TIC_TIC(std::vector<CasADi::MX* >* x0, std::vector<CasADi::MX* >* x1, std::vector<CasADi::MX* >* x2, std::string* x3, std::string* x4)"+// call: "CasADi::extractShared(x0_, x1_, x2_, x3_, x4_)"+extern "C"+ void CasADi__extractShared_TIC_TIC_TIC(std::vector<CasADi::MX* >* x0, std::vector<CasADi::MX* >* x1, std::vector<CasADi::MX* >* x2, std::string* x3, std::string* x4);+void CasADi__extractShared_TIC_TIC_TIC(std::vector<CasADi::MX* >* x0, std::vector<CasADi::MX* >* x1, std::vector<CasADi::MX* >* x2, std::string* x3, std::string* x4){+ std::vector<CasADi::MX > x0_ = Marshaling<std::vector<CasADi::MX >,std::vector<CasADi::MX* >*>::marshal(x0);+ std::vector<CasADi::MX > x1_ = Marshaling<std::vector<CasADi::MX >,std::vector<CasADi::MX* >*>::marshal(x1);+ std::vector<CasADi::MX > x2_ = Marshaling<std::vector<CasADi::MX >,std::vector<CasADi::MX* >*>::marshal(x2);+ std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);+ std::string x4_ = Marshaling<std::string,std::string*>::marshal(x4);++ return CasADi::extractShared(x0_, x1_, x2_, x3_, x4_);+}+++// ================== function "CasADi::extractShared''''" ===============+// cppName: "CasADi::extractShared''''"+// cWrapperName: "CasADi__extractShared_TIC_TIC_TIC_TIC"+// protoArgs: "(std::vector<CasADi::MX* >* x0, std::vector<CasADi::MX* >* x1, std::vector<CasADi::MX* >* x2, std::string* x3)"+// params: [Ref (Vec (NonVec (CasadiClass MX))),Ref (Vec (NonVec (CasadiClass MX))),Ref (Vec (NonVec (CasadiClass MX))),ConstRef (NonVec StdString)]+// args: "(x0_, x1_, x2_, x3_)"+// cWrapperRetType: "void"+// proto: "void CasADi__extractShared_TIC_TIC_TIC_TIC(std::vector<CasADi::MX* >* x0, std::vector<CasADi::MX* >* x1, std::vector<CasADi::MX* >* x2, std::string* x3)"+// call: "CasADi::extractShared(x0_, x1_, x2_, x3_)"+extern "C"+ void CasADi__extractShared_TIC_TIC_TIC_TIC(std::vector<CasADi::MX* >* x0, std::vector<CasADi::MX* >* x1, std::vector<CasADi::MX* >* x2, std::string* x3);+void CasADi__extractShared_TIC_TIC_TIC_TIC(std::vector<CasADi::MX* >* x0, std::vector<CasADi::MX* >* x1, std::vector<CasADi::MX* >* x2, std::string* x3){+ std::vector<CasADi::MX > x0_ = Marshaling<std::vector<CasADi::MX >,std::vector<CasADi::MX* >*>::marshal(x0);+ std::vector<CasADi::MX > x1_ = Marshaling<std::vector<CasADi::MX >,std::vector<CasADi::MX* >*>::marshal(x1);+ std::vector<CasADi::MX > x2_ = Marshaling<std::vector<CasADi::MX >,std::vector<CasADi::MX* >*>::marshal(x2);+ std::string x3_ = Marshaling<std::string,std::string*>::marshal(x3);++ return CasADi::extractShared(x0_, x1_, x2_, x3_);+}+++// ================== function "CasADi::extractShared'''''" ===============+// cppName: "CasADi::extractShared'''''"+// cWrapperName: "CasADi__extractShared_TIC_TIC_TIC_TIC_TIC"+// protoArgs: "(std::vector<CasADi::MX* >* x0, std::vector<CasADi::MX* >* x1, std::vector<CasADi::MX* >* x2)"+// params: [Ref (Vec (NonVec (CasadiClass MX))),Ref (Vec (NonVec (CasadiClass MX))),Ref (Vec (NonVec (CasadiClass MX)))]+// args: "(x0_, x1_, x2_)"+// cWrapperRetType: "void"+// proto: "void CasADi__extractShared_TIC_TIC_TIC_TIC_TIC(std::vector<CasADi::MX* >* x0, std::vector<CasADi::MX* >* x1, std::vector<CasADi::MX* >* x2)"+// call: "CasADi::extractShared(x0_, x1_, x2_)"+extern "C"+ void CasADi__extractShared_TIC_TIC_TIC_TIC_TIC(std::vector<CasADi::MX* >* x0, std::vector<CasADi::MX* >* x1, std::vector<CasADi::MX* >* x2);+void CasADi__extractShared_TIC_TIC_TIC_TIC_TIC(std::vector<CasADi::MX* >* x0, std::vector<CasADi::MX* >* x1, std::vector<CasADi::MX* >* x2){+ std::vector<CasADi::MX > x0_ = Marshaling<std::vector<CasADi::MX >,std::vector<CasADi::MX* >*>::marshal(x0);+ std::vector<CasADi::MX > x1_ = Marshaling<std::vector<CasADi::MX >,std::vector<CasADi::MX* >*>::marshal(x1);+ std::vector<CasADi::MX > x2_ = Marshaling<std::vector<CasADi::MX >,std::vector<CasADi::MX* >*>::marshal(x2);++ return CasADi::extractShared(x0_, x1_, x2_);+}+++// ================== function "CasADi::printCompact'''" ===============+// cppName: "CasADi::printCompact'''"+// cWrapperName: "CasADi__printCompact_TIC_TIC_TIC"+// protoArgs: "(CasADi::MX* x0)"+// params: [ConstRef (NonVec (CasadiClass MX))]+// args: "(x0_)"+// cWrapperRetType: "void"+// proto: "void CasADi__printCompact_TIC_TIC_TIC(CasADi::MX* x0)"+// call: "CasADi::printCompact(x0_)"+extern "C"+ void CasADi__printCompact_TIC_TIC_TIC(CasADi::MX* x0);+void CasADi__printCompact_TIC_TIC_TIC(CasADi::MX* x0){+ CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);++ return CasADi::printCompact(x0_);+}+++// ================== function "CasADi::jacobian'" ===============+// cppName: "CasADi::jacobian'"+// cWrapperName: "CasADi__jacobian_TIC"+// protoArgs: "(CasADi::MX* x0, CasADi::MX* x1)"+// params: [ConstRef (NonVec (CasadiClass MX)),ConstRef (NonVec (CasadiClass MX))]+// args: "(x0_, x1_)"+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__jacobian_TIC(CasADi::MX* x0, CasADi::MX* x1)"+// call: "CasADi::jacobian(x0_, x1_)"+extern "C"+ CasADi::MX* CasADi__jacobian_TIC(CasADi::MX* x0, CasADi::MX* x1);+CasADi::MX* CasADi__jacobian_TIC(CasADi::MX* x0, CasADi::MX* x1){+ CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);+ CasADi::MX x1_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x1);++ return new CasADi::MX( CasADi::jacobian(x0_, x1_) );+}+++// ================== function "CasADi::gradient'" ===============+// cppName: "CasADi::gradient'"+// cWrapperName: "CasADi__gradient_TIC"+// protoArgs: "(CasADi::MX* x0, CasADi::MX* x1)"+// params: [ConstRef (NonVec (CasadiClass MX)),ConstRef (NonVec (CasadiClass MX))]+// args: "(x0_, x1_)"+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__gradient_TIC(CasADi::MX* x0, CasADi::MX* x1)"+// call: "CasADi::gradient(x0_, x1_)"+extern "C"+ CasADi::MX* CasADi__gradient_TIC(CasADi::MX* x0, CasADi::MX* x1);+CasADi::MX* CasADi__gradient_TIC(CasADi::MX* x0, CasADi::MX* x1){+ CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);+ CasADi::MX x1_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x1);++ return new CasADi::MX( CasADi::gradient(x0_, x1_) );+}+++// ================== function "CasADi::tangent'" ===============+// cppName: "CasADi::tangent'"+// cWrapperName: "CasADi__tangent_TIC"+// protoArgs: "(CasADi::MX* x0, CasADi::MX* x1)"+// params: [ConstRef (NonVec (CasadiClass MX)),ConstRef (NonVec (CasadiClass MX))]+// args: "(x0_, x1_)"+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__tangent_TIC(CasADi::MX* x0, CasADi::MX* x1)"+// call: "CasADi::tangent(x0_, x1_)"+extern "C"+ CasADi::MX* CasADi__tangent_TIC(CasADi::MX* x0, CasADi::MX* x1);+CasADi::MX* CasADi__tangent_TIC(CasADi::MX* x0, CasADi::MX* x1){+ CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);+ CasADi::MX x1_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x1);++ return new CasADi::MX( CasADi::tangent(x0_, x1_) );+}+++// ================== function "CasADi::nullspace'''" ===============+// cppName: "CasADi::nullspace'''"+// cWrapperName: "CasADi__nullspace_TIC_TIC_TIC"+// protoArgs: "(CasADi::MX* x0)"+// params: [ConstRef (NonVec (CasadiClass MX))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__nullspace_TIC_TIC_TIC(CasADi::MX* x0)"+// call: "CasADi::nullspace(x0_)"+extern "C"+ CasADi::MX* CasADi__nullspace_TIC_TIC_TIC(CasADi::MX* x0);+CasADi::MX* CasADi__nullspace_TIC_TIC_TIC(CasADi::MX* x0){+ CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);++ return new CasADi::MX( CasADi::nullspace(x0_) );+}+++// ================== function "CasADi::det'''" ===============+// cppName: "CasADi::det'''"+// cWrapperName: "CasADi__det_TIC_TIC_TIC"+// protoArgs: "(CasADi::MX* x0)"+// params: [ConstRef (NonVec (CasadiClass MX))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__det_TIC_TIC_TIC(CasADi::MX* x0)"+// call: "CasADi::det(x0_)"+extern "C"+ CasADi::MX* CasADi__det_TIC_TIC_TIC(CasADi::MX* x0);+CasADi::MX* CasADi__det_TIC_TIC_TIC(CasADi::MX* x0){+ CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);++ return new CasADi::MX( CasADi::det(x0_) );+}+++// ================== function "CasADi::inv'''" ===============+// cppName: "CasADi::inv'''"+// cWrapperName: "CasADi__inv_TIC_TIC_TIC"+// protoArgs: "(CasADi::MX* x0)"+// params: [ConstRef (NonVec (CasadiClass MX))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__inv_TIC_TIC_TIC(CasADi::MX* x0)"+// call: "CasADi::inv(x0_)"+extern "C"+ CasADi::MX* CasADi__inv_TIC_TIC_TIC(CasADi::MX* x0);+CasADi::MX* CasADi__inv_TIC_TIC_TIC(CasADi::MX* x0){+ CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);++ return new CasADi::MX( CasADi::inv(x0_) );+}+++// ================== function "CasADi::getSymbols'" ===============+// cppName: "CasADi::getSymbols'"+// cWrapperName: "CasADi__getSymbols_TIC"+// protoArgs: "(CasADi::MX* x0)"+// params: [ConstRef (NonVec (CasadiClass MX))]+// args: "(x0_)"+// cWrapperRetType: "std::vector<CasADi::MX >*"+// proto: "std::vector<CasADi::MX >* CasADi__getSymbols_TIC(CasADi::MX* x0)"+// call: "CasADi::getSymbols(x0_)"+extern "C"+ std::vector<CasADi::MX >* CasADi__getSymbols_TIC(CasADi::MX* x0);+std::vector<CasADi::MX >* CasADi__getSymbols_TIC(CasADi::MX* x0){+ CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);++ return new std::vector<CasADi::MX >( CasADi::getSymbols(x0_) );+}+++// ================== function "CasADi::getSymbols''" ===============+// cppName: "CasADi::getSymbols''"+// cWrapperName: "CasADi__getSymbols_TIC_TIC"+// protoArgs: "(std::vector<CasADi::MX* > * x0)"+// params: [ConstRef (Vec (NonVec (CasadiClass MX)))]+// args: "(x0_)"+// cWrapperRetType: "std::vector<CasADi::MX >*"+// proto: "std::vector<CasADi::MX >* CasADi__getSymbols_TIC_TIC(std::vector<CasADi::MX* > * x0)"+// call: "CasADi::getSymbols(x0_)"+extern "C"+ std::vector<CasADi::MX >* CasADi__getSymbols_TIC_TIC(std::vector<CasADi::MX* > * x0);+std::vector<CasADi::MX >* CasADi__getSymbols_TIC_TIC(std::vector<CasADi::MX* > * x0){+ std::vector<CasADi::MX > x0_ = Marshaling<std::vector<CasADi::MX >,std::vector<CasADi::MX* > *>::marshal(x0);++ return new std::vector<CasADi::MX >( CasADi::getSymbols(x0_) );+}+++// ================== function "CasADi::matrix_expand" ===============+// cppName: "CasADi::matrix_expand"+// cWrapperName: "CasADi__matrix_expand"+// protoArgs: "(CasADi::MX* x0, std::vector<CasADi::MX* > * x1)"+// params: [ConstRef (NonVec (CasadiClass MX)),ConstRef (Vec (NonVec (CasadiClass MX)))]+// args: "(x0_, x1_)"+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__matrix_expand(CasADi::MX* x0, std::vector<CasADi::MX* > * x1)"+// call: "CasADi::matrix_expand(x0_, x1_)"+extern "C"+ CasADi::MX* CasADi__matrix_expand(CasADi::MX* x0, std::vector<CasADi::MX* > * x1);+CasADi::MX* CasADi__matrix_expand(CasADi::MX* x0, std::vector<CasADi::MX* > * x1){+ CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);+ std::vector<CasADi::MX > x1_ = Marshaling<std::vector<CasADi::MX >,std::vector<CasADi::MX* > *>::marshal(x1);++ return new CasADi::MX( CasADi::matrix_expand(x0_, x1_) );+}+++// ================== function "CasADi::matrix_expand'" ===============+// cppName: "CasADi::matrix_expand'"+// cWrapperName: "CasADi__matrix_expand_TIC"+// protoArgs: "(CasADi::MX* x0)"+// params: [ConstRef (NonVec (CasadiClass MX))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__matrix_expand_TIC(CasADi::MX* x0)"+// call: "CasADi::matrix_expand(x0_)"+extern "C"+ CasADi::MX* CasADi__matrix_expand_TIC(CasADi::MX* x0);+CasADi::MX* CasADi__matrix_expand_TIC(CasADi::MX* x0){+ CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);++ return new CasADi::MX( CasADi::matrix_expand(x0_) );+}+++// ================== function "CasADi::matrix_expand''" ===============+// cppName: "CasADi::matrix_expand''"+// cWrapperName: "CasADi__matrix_expand_TIC_TIC"+// protoArgs: "(std::vector<CasADi::MX* > * x0, std::vector<CasADi::MX* > * x1)"+// params: [ConstRef (Vec (NonVec (CasadiClass MX))),ConstRef (Vec (NonVec (CasadiClass MX)))]+// args: "(x0_, x1_)"+// cWrapperRetType: "std::vector<CasADi::MX >*"+// proto: "std::vector<CasADi::MX >* CasADi__matrix_expand_TIC_TIC(std::vector<CasADi::MX* > * x0, std::vector<CasADi::MX* > * x1)"+// call: "CasADi::matrix_expand(x0_, x1_)"+extern "C"+ std::vector<CasADi::MX >* CasADi__matrix_expand_TIC_TIC(std::vector<CasADi::MX* > * x0, std::vector<CasADi::MX* > * x1);+std::vector<CasADi::MX >* CasADi__matrix_expand_TIC_TIC(std::vector<CasADi::MX* > * x0, std::vector<CasADi::MX* > * x1){+ std::vector<CasADi::MX > x0_ = Marshaling<std::vector<CasADi::MX >,std::vector<CasADi::MX* > *>::marshal(x0);+ std::vector<CasADi::MX > x1_ = Marshaling<std::vector<CasADi::MX >,std::vector<CasADi::MX* > *>::marshal(x1);++ return new std::vector<CasADi::MX >( CasADi::matrix_expand(x0_, x1_) );+}+++// ================== function "CasADi::matrix_expand'''" ===============+// cppName: "CasADi::matrix_expand'''"+// cWrapperName: "CasADi__matrix_expand_TIC_TIC_TIC"+// protoArgs: "(std::vector<CasADi::MX* > * x0)"+// params: [ConstRef (Vec (NonVec (CasadiClass MX)))]+// args: "(x0_)"+// cWrapperRetType: "std::vector<CasADi::MX >*"+// proto: "std::vector<CasADi::MX >* CasADi__matrix_expand_TIC_TIC_TIC(std::vector<CasADi::MX* > * x0)"+// call: "CasADi::matrix_expand(x0_)"+extern "C"+ std::vector<CasADi::MX >* CasADi__matrix_expand_TIC_TIC_TIC(std::vector<CasADi::MX* > * x0);+std::vector<CasADi::MX >* CasADi__matrix_expand_TIC_TIC_TIC(std::vector<CasADi::MX* > * x0){+ std::vector<CasADi::MX > x0_ = Marshaling<std::vector<CasADi::MX >,std::vector<CasADi::MX* > *>::marshal(x0);++ return new std::vector<CasADi::MX >( CasADi::matrix_expand(x0_) );+}+++// ================== function "CasADi::kron'''" ===============+// cppName: "CasADi::kron'''"+// cWrapperName: "CasADi__kron_TIC_TIC_TIC"+// protoArgs: "(CasADi::MX* x0, CasADi::MX* x1)"+// params: [ConstRef (NonVec (CasadiClass MX)),ConstRef (NonVec (CasadiClass MX))]+// args: "(x0_, x1_)"+// cWrapperRetType: "CasADi::MX*"+// proto: "CasADi::MX* CasADi__kron_TIC_TIC_TIC(CasADi::MX* x0, CasADi::MX* x1)"+// call: "CasADi::kron(x0_, x1_)"+extern "C"+ CasADi::MX* CasADi__kron_TIC_TIC_TIC(CasADi::MX* x0, CasADi::MX* x1);+CasADi::MX* CasADi__kron_TIC_TIC_TIC(CasADi::MX* x0, CasADi::MX* x1){+ CasADi::MX x0_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x0);+ CasADi::MX x1_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x1);++ return new CasADi::MX( CasADi::kron(x0_, x1_) );+}+++// ================== function "CasADi::parameterizeTime" ===============+// cppName: "CasADi::parameterizeTime"+// cWrapperName: "CasADi__parameterizeTime"+// protoArgs: "(CasADi::FX* x0)"+// params: [Val (NonVec (CasadiClass FX))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::FX*"+// proto: "CasADi::FX* CasADi__parameterizeTime(CasADi::FX* x0)"+// call: "CasADi::parameterizeTime(x0_)"+extern "C"+ CasADi::FX* CasADi__parameterizeTime(CasADi::FX* x0);+CasADi::FX* CasADi__parameterizeTime(CasADi::FX* x0){+ CasADi::FX x0_ = Marshaling<CasADi::FX,CasADi::FX*>::marshal(x0);++ return new CasADi::FX( CasADi::parameterizeTime(x0_) );+}+++// ================== function "CasADi::parameterizeTimeOutput" ===============+// cppName: "CasADi::parameterizeTimeOutput"+// cWrapperName: "CasADi__parameterizeTimeOutput"+// protoArgs: "(CasADi::FX* x0)"+// params: [Val (NonVec (CasadiClass FX))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::FX*"+// proto: "CasADi::FX* CasADi__parameterizeTimeOutput(CasADi::FX* x0)"+// call: "CasADi::parameterizeTimeOutput(x0_)"+extern "C"+ CasADi::FX* CasADi__parameterizeTimeOutput(CasADi::FX* x0);+CasADi::FX* CasADi__parameterizeTimeOutput(CasADi::FX* x0){+ CasADi::FX x0_ = Marshaling<CasADi::FX,CasADi::FX*>::marshal(x0);++ return new CasADi::FX( CasADi::parameterizeTimeOutput(x0_) );+}+++// ================== function "CasADi::numSample1D" ===============+// cppName: "CasADi::numSample1D"+// cWrapperName: "CasADi__numSample1D"+// protoArgs: "(CasADi::FX* x0, CasADi::Matrix< double >* x1)"+// params: [Ref (NonVec (CasadiClass FX)),ConstRef (NonVec (CasadiClass DMatrix))]+// args: "(x0_, x1_)"+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__numSample1D(CasADi::FX* x0, CasADi::Matrix< double >* x1)"+// call: "CasADi::numSample1D(x0_, x1_)"+extern "C"+ CasADi::Matrix< double >* CasADi__numSample1D(CasADi::FX* x0, CasADi::Matrix< double >* x1);+CasADi::Matrix< double >* CasADi__numSample1D(CasADi::FX* x0, CasADi::Matrix< double >* x1){+ CasADi::FX x0_ = Marshaling<CasADi::FX,CasADi::FX*>::marshal(x0);+ CasADi::Matrix< double > x1_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x1);++ return new CasADi::Matrix< double >( CasADi::numSample1D(x0_, x1_) );+}+++// ================== function "CasADi::numSample1DT" ===============+// cppName: "CasADi::numSample1DT"+// cWrapperName: "CasADi__numSample1DT"+// protoArgs: "(CasADi::FX* x0, CasADi::Matrix< double >* x1)"+// params: [Ref (NonVec (CasadiClass FX)),ConstRef (NonVec (CasadiClass DMatrix))]+// args: "(x0_, x1_)"+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__numSample1DT(CasADi::FX* x0, CasADi::Matrix< double >* x1)"+// call: "CasADi::numSample1DT(x0_, x1_)"+extern "C"+ CasADi::Matrix< double >* CasADi__numSample1DT(CasADi::FX* x0, CasADi::Matrix< double >* x1);+CasADi::Matrix< double >* CasADi__numSample1DT(CasADi::FX* x0, CasADi::Matrix< double >* x1){+ CasADi::FX x0_ = Marshaling<CasADi::FX,CasADi::FX*>::marshal(x0);+ CasADi::Matrix< double > x1_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x1);++ return new CasADi::Matrix< double >( CasADi::numSample1DT(x0_, x1_) );+}+++// ================== function "CasADi::numSample2D" ===============+// cppName: "CasADi::numSample2D"+// cWrapperName: "CasADi__numSample2D"+// protoArgs: "(CasADi::FX* x0, CasADi::Matrix< double >* x1)"+// params: [Ref (NonVec (CasadiClass FX)),ConstRef (NonVec (CasadiClass DMatrix))]+// args: "(x0_, x1_)"+// cWrapperRetType: "CasADi::Matrix< double >*"+// proto: "CasADi::Matrix< double >* CasADi__numSample2D(CasADi::FX* x0, CasADi::Matrix< double >* x1)"+// call: "CasADi::numSample2D(x0_, x1_)"+extern "C"+ CasADi::Matrix< double >* CasADi__numSample2D(CasADi::FX* x0, CasADi::Matrix< double >* x1);+CasADi::Matrix< double >* CasADi__numSample2D(CasADi::FX* x0, CasADi::Matrix< double >* x1){+ CasADi::FX x0_ = Marshaling<CasADi::FX,CasADi::FX*>::marshal(x0);+ CasADi::Matrix< double > x1_ = Marshaling<CasADi::Matrix< double >,CasADi::Matrix< double >*>::marshal(x1);++ return new CasADi::Matrix< double >( CasADi::numSample2D(x0_, x1_) );+}+++// ================== function "CasADi::vec'''''" ===============+// cppName: "CasADi::vec'''''"+// cWrapperName: "CasADi__vec_TIC_TIC_TIC_TIC_TIC"+// protoArgs: "(CasADi::SXFunction* x0)"+// params: [ConstRef (NonVec (CasadiClass SXFunction))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::SXFunction*"+// proto: "CasADi::SXFunction* CasADi__vec_TIC_TIC_TIC_TIC_TIC(CasADi::SXFunction* x0)"+// call: "CasADi::vec(x0_)"+extern "C"+ CasADi::SXFunction* CasADi__vec_TIC_TIC_TIC_TIC_TIC(CasADi::SXFunction* x0);+CasADi::SXFunction* CasADi__vec_TIC_TIC_TIC_TIC_TIC(CasADi::SXFunction* x0){+ CasADi::SXFunction x0_ = Marshaling<CasADi::SXFunction,CasADi::SXFunction*>::marshal(x0);++ return new CasADi::SXFunction( CasADi::vec(x0_) );+}+++// ================== function "CasADi::vec''''''" ===============+// cppName: "CasADi::vec''''''"+// cWrapperName: "CasADi__vec_TIC_TIC_TIC_TIC_TIC_TIC"+// protoArgs: "(CasADi::FX* x0)"+// params: [ConstRef (NonVec (CasadiClass FX))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::MXFunction*"+// proto: "CasADi::MXFunction* CasADi__vec_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::FX* x0)"+// call: "CasADi::vec(x0_)"+extern "C"+ CasADi::MXFunction* CasADi__vec_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::FX* x0);+CasADi::MXFunction* CasADi__vec_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::FX* x0){+ CasADi::FX x0_ = Marshaling<CasADi::FX,CasADi::FX*>::marshal(x0);++ return new CasADi::MXFunction( CasADi::vec(x0_) );+}+++// ================== function "CasADi::collocationPoints" ===============+// cppName: "CasADi::collocationPoints"+// cWrapperName: "CasADi__collocationPoints"+// protoArgs: "(int x0, std::string* x1)"+// params: [Val (NonVec CInt),ConstRef (NonVec StdString)]+// args: "(x0_, x1_)"+// cWrapperRetType: "std::vector<double >*"+// proto: "std::vector<double >* CasADi__collocationPoints(int x0, std::string* x1)"+// call: "CasADi::collocationPoints(x0_, x1_)"+extern "C"+ std::vector<double >* CasADi__collocationPoints(int x0, std::string* x1);+std::vector<double >* CasADi__collocationPoints(int x0, std::string* x1){+ int x0_ = Marshaling<int,int>::marshal(x0);+ std::string x1_ = Marshaling<std::string,std::string*>::marshal(x1);++ return new std::vector<double >( CasADi::collocationPoints(x0_, x1_) );+}+++// ================== function "CasADi::collocationPoints'" ===============+// cppName: "CasADi::collocationPoints'"+// cWrapperName: "CasADi__collocationPoints_TIC"+// protoArgs: "(int x0)"+// params: [Val (NonVec CInt)]+// args: "(x0_)"+// cWrapperRetType: "std::vector<double >*"+// proto: "std::vector<double >* CasADi__collocationPoints_TIC(int x0)"+// call: "CasADi::collocationPoints(x0_)"+extern "C"+ std::vector<double >* CasADi__collocationPoints_TIC(int x0);+std::vector<double >* CasADi__collocationPoints_TIC(int x0){+ int x0_ = Marshaling<int,int>::marshal(x0);++ return new std::vector<double >( CasADi::collocationPoints(x0_) );+}+++// ================== function "CasADi::collocationInterpolators" ===============+// cppName: "CasADi::collocationInterpolators"+// cWrapperName: "CasADi__collocationInterpolators"+// protoArgs: "(std::vector<double > * x0, std::vector<std::vector<double > >* x1, std::vector<double >* x2)"+// params: [ConstRef (Vec (NonVec CDouble)),Ref (Vec (Vec (NonVec CDouble))),Ref (Vec (NonVec CDouble))]+// args: "(x0_, x1_, x2_)"+// cWrapperRetType: "void"+// proto: "void CasADi__collocationInterpolators(std::vector<double > * x0, std::vector<std::vector<double > >* x1, std::vector<double >* x2)"+// call: "CasADi::collocationInterpolators(x0_, x1_, x2_)"+extern "C"+ void CasADi__collocationInterpolators(std::vector<double > * x0, std::vector<std::vector<double > >* x1, std::vector<double >* x2);+void CasADi__collocationInterpolators(std::vector<double > * x0, std::vector<std::vector<double > >* x1, std::vector<double >* x2){+ std::vector<double > x0_ = Marshaling<std::vector<double >,std::vector<double > *>::marshal(x0);+ std::vector<std::vector<double > > x1_ = Marshaling<std::vector<std::vector<double > >,std::vector<std::vector<double > >*>::marshal(x1);+ std::vector<double > x2_ = Marshaling<std::vector<double >,std::vector<double >*>::marshal(x2);++ return CasADi::collocationInterpolators(x0_, x1_, x2_);+}+++// ================== function "CasADi::explicitRK" ===============+// cppName: "CasADi::explicitRK"+// cWrapperName: "CasADi__explicitRK"+// protoArgs: "(CasADi::FX* x0, CasADi::MX* x1, int x2, int x3)"+// params: [Ref (NonVec (CasadiClass FX)),ConstRef (NonVec (CasadiClass MX)),Val (NonVec CInt),Val (NonVec CInt)]+// args: "(x0_, x1_, x2_, x3_)"+// cWrapperRetType: "CasADi::FX*"+// proto: "CasADi::FX* CasADi__explicitRK(CasADi::FX* x0, CasADi::MX* x1, int x2, int x3)"+// call: "CasADi::explicitRK(x0_, x1_, x2_, x3_)"+extern "C"+ CasADi::FX* CasADi__explicitRK(CasADi::FX* x0, CasADi::MX* x1, int x2, int x3);+CasADi::FX* CasADi__explicitRK(CasADi::FX* x0, CasADi::MX* x1, int x2, int x3){+ CasADi::FX x0_ = Marshaling<CasADi::FX,CasADi::FX*>::marshal(x0);+ CasADi::MX x1_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x1);+ int x2_ = Marshaling<int,int>::marshal(x2);+ int x3_ = Marshaling<int,int>::marshal(x3);++ return new CasADi::FX( CasADi::explicitRK(x0_, x1_, x2_, x3_) );+}+++// ================== function "CasADi::explicitRK'" ===============+// cppName: "CasADi::explicitRK'"+// cWrapperName: "CasADi__explicitRK_TIC"+// protoArgs: "(CasADi::FX* x0, CasADi::MX* x1, int x2)"+// params: [Ref (NonVec (CasadiClass FX)),ConstRef (NonVec (CasadiClass MX)),Val (NonVec CInt)]+// args: "(x0_, x1_, x2_)"+// cWrapperRetType: "CasADi::FX*"+// proto: "CasADi::FX* CasADi__explicitRK_TIC(CasADi::FX* x0, CasADi::MX* x1, int x2)"+// call: "CasADi::explicitRK(x0_, x1_, x2_)"+extern "C"+ CasADi::FX* CasADi__explicitRK_TIC(CasADi::FX* x0, CasADi::MX* x1, int x2);+CasADi::FX* CasADi__explicitRK_TIC(CasADi::FX* x0, CasADi::MX* x1, int x2){+ CasADi::FX x0_ = Marshaling<CasADi::FX,CasADi::FX*>::marshal(x0);+ CasADi::MX x1_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x1);+ int x2_ = Marshaling<int,int>::marshal(x2);++ return new CasADi::FX( CasADi::explicitRK(x0_, x1_, x2_) );+}+++// ================== function "CasADi::explicitRK''" ===============+// cppName: "CasADi::explicitRK''"+// cWrapperName: "CasADi__explicitRK_TIC_TIC"+// protoArgs: "(CasADi::FX* x0, CasADi::MX* x1)"+// params: [Ref (NonVec (CasadiClass FX)),ConstRef (NonVec (CasadiClass MX))]+// args: "(x0_, x1_)"+// cWrapperRetType: "CasADi::FX*"+// proto: "CasADi::FX* CasADi__explicitRK_TIC_TIC(CasADi::FX* x0, CasADi::MX* x1)"+// call: "CasADi::explicitRK(x0_, x1_)"+extern "C"+ CasADi::FX* CasADi__explicitRK_TIC_TIC(CasADi::FX* x0, CasADi::MX* x1);+CasADi::FX* CasADi__explicitRK_TIC_TIC(CasADi::FX* x0, CasADi::MX* x1){+ CasADi::FX x0_ = Marshaling<CasADi::FX,CasADi::FX*>::marshal(x0);+ CasADi::MX x1_ = Marshaling<CasADi::MX,CasADi::MX*>::marshal(x1);++ return new CasADi::FX( CasADi::explicitRK(x0_, x1_) );+}+++// ================== function "CasADi::explicitRK'''" ===============+// cppName: "CasADi::explicitRK'''"+// cWrapperName: "CasADi__explicitRK_TIC_TIC_TIC"+// protoArgs: "(CasADi::FX* x0)"+// params: [Ref (NonVec (CasadiClass FX))]+// args: "(x0_)"+// cWrapperRetType: "CasADi::FX*"+// proto: "CasADi::FX* CasADi__explicitRK_TIC_TIC_TIC(CasADi::FX* x0)"+// call: "CasADi::explicitRK(x0_)"+extern "C"+ CasADi::FX* CasADi__explicitRK_TIC_TIC_TIC(CasADi::FX* x0);+CasADi::FX* CasADi__explicitRK_TIC_TIC_TIC(CasADi::FX* x0){+ CasADi::FX x0_ = Marshaling<CasADi::FX,CasADi::FX*>::marshal(x0);++ return new CasADi::FX( CasADi::explicitRK(x0_) );+}+++// ================== delete CInt===============+// classType: CInt+extern "C"+ void delete_std__vector_int_(std::vector<int >* obj);+void delete_std__vector_int_(std::vector<int >* obj){+ delete obj;+}+extern "C"+ void delete_std__vector_std__vector_int__(std::vector<std::vector<int > >* obj);+void delete_std__vector_std__vector_int__(std::vector<std::vector<int > >* obj){+ delete obj;+}+extern "C"+ void delete_std__vector_std__vector_std__vector_int___(std::vector<std::vector<std::vector<int > > >* obj);+void delete_std__vector_std__vector_std__vector_int___(std::vector<std::vector<std::vector<int > > >* obj){+ delete obj;+}++// ================== delete CDouble===============+// classType: CDouble+extern "C"+ void delete_std__vector_double_(std::vector<double >* obj);+void delete_std__vector_double_(std::vector<double >* obj){+ delete obj;+}+extern "C"+ void delete_std__vector_std__vector_double__(std::vector<std::vector<double > >* obj);+void delete_std__vector_std__vector_double__(std::vector<std::vector<double > >* obj){+ delete obj;+}+extern "C"+ void delete_std__vector_std__vector_std__vector_double___(std::vector<std::vector<std::vector<double > > >* obj);+void delete_std__vector_std__vector_std__vector_double___(std::vector<std::vector<std::vector<double > > >* obj){+ delete obj;+}++// ================== delete StdString===============+// classType: StdString+extern "C"+ void delete_std__string(std::string* obj);+void delete_std__string(std::string* obj){+ delete obj;+}+extern "C"+ void delete_std__vector_std__string_(std::vector<std::string* >* obj);+void delete_std__vector_std__string_(std::vector<std::string* >* obj){+ delete obj;+}+extern "C"+ void delete_std__vector_std__vector_std__string__(std::vector<std::vector<std::string* > >* obj);+void delete_std__vector_std__vector_std__string__(std::vector<std::vector<std::string* > >* obj){+ delete obj;+}+extern "C"+ void delete_std__vector_std__vector_std__vector_std__string___(std::vector<std::vector<std::vector<std::string* > > >* obj);+void delete_std__vector_std__vector_std__vector_std__string___(std::vector<std::vector<std::vector<std::string* > > >* obj){+ delete obj;+}++// ================== delete CBool===============+// classType: CBool+extern "C"+ void delete_bool(bool* obj);+void delete_bool(bool* obj){+ delete obj;+}+extern "C"+ void delete_std__vector_bool_(std::vector<bool* >* obj);+void delete_std__vector_bool_(std::vector<bool* >* obj){+ delete obj;+}+extern "C"+ void delete_std__vector_std__vector_bool__(std::vector<std::vector<bool* > >* obj);+void delete_std__vector_std__vector_bool__(std::vector<std::vector<bool* > >* obj){+ delete obj;+}+extern "C"+ void delete_std__vector_std__vector_std__vector_bool___(std::vector<std::vector<std::vector<bool* > > >* obj);+void delete_std__vector_std__vector_std__vector_bool___(std::vector<std::vector<std::vector<bool* > > >* obj){+ delete obj;+}
+ cbits/callback.cpp view
@@ -0,0 +1,56 @@+#include <iostream>+#include <symbolic/casadi.hpp>+#include "symbolic/fx/custom_function.hpp"+#include "symbolic/functor_internal.hpp"++#include "HsFFI.h"++using namespace std;+using namespace CasADi;++extern "C" {+typedef int (*hs_callback_t)(FX &f);+}++namespace CasADi {+ class FunctorHaskellInternal {+ public:+ FunctorHaskellInternal(hs_callback_t hscb)+ {+ hs_callback = hscb;+ }+ ~FunctorHaskellInternal() {+ // free the haskell FunPtr+ hs_free_fun_ptr(HsFunPtr(hs_callback));+ }+ protected:+ hs_callback_t hs_callback;+ };++ class CallbackHaskellInternal : public CallbackInternal, FunctorHaskellInternal {+ friend class CallbackHaskell;++ CallbackHaskellInternal(hs_callback_t hscb) : FunctorHaskellInternal(hscb) {}+ virtual int call(FX& fcn, void* user_data);+ virtual CallbackHaskellInternal* clone() const { return new CallbackHaskellInternal(hs_callback); }+ };++ class CallbackHaskell : public Callback {+ public:+ CallbackHaskell(hs_callback_t hscb) { assignNode(new CallbackHaskellInternal(hscb)); }+ };++ int CallbackHaskellInternal::call(FX& fcn, void* user_data) {+ return hs_callback(fcn);+ }+}++extern "C" CallbackHaskell * new_callback_haskell(hs_callback_t hs_callback);+CallbackHaskell * new_callback_haskell(hs_callback_t hs_callback){+ return new CallbackHaskell(hs_callback);+}++extern "C" void delete_callback_haskell(CasADi::CallbackHaskell* obj);+void delete_callback_haskell(CasADi::CallbackHaskell* obj){+ delete obj;+}
+ cbits/hs_tools.cpp view
@@ -0,0 +1,123 @@+#include <iostream>+#include <vector>+#include "string.h"++using namespace std;++///////////// scalars /////////////+// bool+extern "C" int hs_read_bool(bool * x);+int hs_read_bool(bool * x){+ if (*x == false)+ return 0;+ else+ return 1;+}+extern "C" bool * hs_new_bool(int x);+bool * hs_new_bool(int x){+ if (x == 0)+ return new bool(false);+ else+ return new bool(true);+}+extern "C" void hs_delete_bool(bool * x);+void hs_delete_bool(bool * x){ delete x; }++// string+extern "C" int hs_string_length(string * str);+int hs_string_length(string * str){+ return str->length();+}+extern "C" void hs_string_copy(string * str, char outputs[]);+void hs_string_copy(string * str, char outputs[]){+ strcpy(outputs, str->c_str());+}+extern "C" string * hs_new_string(char x[]);+string * hs_new_string(char x[]){+ return new string(x);+}+extern "C" void hs_delete_string(string * x);+void hs_delete_string(string * x){+ delete x;+}+++////////////////////////// copying vectors to arrays /////////////////////+template <typename T>+void hs_vec_copy_T(vector<T> * vec, T outputs[]){+ memcpy(outputs, &((*vec)[0]), vec->size()*sizeof(T));+}++// 2d void pointers+template <typename T>+void hs_vec_vec_sizes_T(vector<vector<T> > * vec, int sizes[]){+ for (unsigned int k=0; k<vec->size(); k++){+ sizes[k] = (*vec)[k].size();+ }+}+template <typename T>+void hs_vec_vec_copy_T(vector<vector<T> > * vec, T* outputs[]){+ for (unsigned int k=0; k<vec->size(); k++){+ memcpy(outputs[k], &(vec[k][0]), vec[k].size()*sizeof(T));+ }+}+++////////////////////// CREATING VECTORS FROM ARRAYS ///////////////////////////////////+// 1-dimensional+template <typename T>+vector<T> * hs_new_vec_T(T inputs[], int length){+ vector<T> vec;+ for (int k=0; k<length; k++)+ vec.push_back(inputs[k]);+ return new vector<T>(vec);+}++// 2-dimensional+template <typename T>+vector<vector<T> > * hs_new_vec_vec_T(T inputs[], int length_outer, int lengths_inner[]){+ vector<vector<T> > vec;+ int counter = 0;+ for (int k=0; k<length_outer; k++){+ vector<T> inner;+ for (int j=0; j<lengths_inner[k]; j++){+ inner.push_back( inputs[counter] );+ counter++;+ }+ vec.push_back(inner);+ }+ return new vector<vector<T> >(vec);+}++////////////////////////////////////////////////////////////////////////////////////////////+#define WRITE_STUFF(name, type) \+ extern "C" vector<type>* hs_new_vec_##name( type inputs[], int length); \+ vector<type>* hs_new_vec_##name( type inputs[], int length){return hs_new_vec_T(inputs, length);} \+ extern "C" void hs_delete_vec_##name(vector<type> * vec); \+ void hs_delete_vec_##name(vector<type> * vec){ delete vec; } \+ \+ extern "C" vector<vector<type> > * hs_new_vec_vec_##name(type x[], int y, int z[]); \+ vector<vector<type> > * hs_new_vec_vec_##name(type x[], int y, int z[]){ return hs_new_vec_vec_T(x,y,z); } \+ extern "C" void hs_delete_vec_vec_##name(vector<vector<type> > * vec); \+ void hs_delete_vec_vec_##name(vector<vector<type> > * vec){ delete vec; } \+ \+ extern "C" void hs_vec_copy_##name(vector<type> * vec, type outputs[]); \+ void hs_vec_copy_##name(vector<type> * vec, type outputs[]){hs_vec_copy_T(vec, outputs);} \+ extern "C" int hs_vec_size_##name(vector<type> * vec); \+ int hs_vec_size_##name(vector<type> * vec){ return vec->size(); } \+ \+ extern "C" int hs_vec_vec_size_##name(vector<vector<type> > * vec); \+ int hs_vec_vec_size_##name(vector<vector<type> > * vec){ return vec->size(); } \+ extern "C" void hs_vec_vec_sizes_##name(vector<vector<type> > * vec, int sizes[]); \+ void hs_vec_vec_sizes_##name(vector<vector<type> > * vec, int sizes[]){ \+ hs_vec_vec_sizes_T(vec, sizes); \+ } \+ extern "C" void hs_vec_vec_copy_##name(vector<vector<type> > * vec, type* outputs[]); \+ void hs_vec_vec_copy_##name(vector<vector<type> > * vec, type* outputs[]){ \+ hs_vec_vec_copy_T(vec, outputs); \+ }++WRITE_STUFF(int,int)+WRITE_STUFF(voidp, void*)+WRITE_STUFF(uchar, unsigned char)+WRITE_STUFF(double, double)
+ cbits/marshal.hpp view
@@ -0,0 +1,106 @@+#ifndef __MARSHAL_THEM_BINDINGS_H__+#define __MARSHAL_THEM_BINDINGS_H__++#include <iostream>+#include <symbolic/casadi.hpp>+++template<class T1, class T2>+class Marshaling {+ public:+ static T1 marshal(T2 x) {+ return x;+ }+}; ++template<class T>+class Marshaling< T, T* > {+ public:+ static T marshal(T* x){+ return *x;+ }+};++template<class T1, class T2>+class Marshaling< std::vector< T1 >,std::vector< T2* > &> {+ public:+ static std::vector< T1 > marshal(const std::vector< T2* > & inputs){+ std::vector< T1 > vec;+ for (unsigned int k=0; k<inputs.size(); k++){+ vec.push_back( Marshaling< T1, T2* >::marshal(inputs[k]) );+ }+ return vec;+ }+};+// pointer to ref+template<class T1, class T2>+class Marshaling< std::vector< T1 >,std::vector< T2* > *> {+ public:+ static std::vector< T1 > marshal(const std::vector< T2* > * inputs){+ return Marshaling< std::vector<T1>, std::vector<T2*>& >::marshal(*inputs);+ }+};+++template<class T1, class T2>+class Marshaling< const std::vector< T1 >,const std::vector< T2* > & > {+ public:+ static const std::vector< T1 > marshal(const std::vector< T2* > & inputs){+ std::vector< T1 > vec;+ for (unsigned int k=0; k<inputs.size(); k++){+ vec.push_back( Marshaling< T1, T2* >::marshal(inputs[k]) );+ }+ return vec;+ }+};+// pointer to ref+template<class T1, class T2>+class Marshaling< const std::vector< T1 >,const std::vector< T2* > *> {+ public:+ static const std::vector< T1 > marshal(const std::vector< T2* > * inputs){+ return Marshaling< const std::vector<T1>, const std::vector<T2> & >::marshal(*inputs);+ }+};+++template<class T1, class T2>+class Marshaling< std::vector< std::vector< T1 > >,std::vector< std::vector< T2*> > &> {+ public:+ static std::vector< std::vector< T1 > > marshal(const std::vector< std::vector< T2* > > & inputs){+ std::vector< std::vector< T1 > > vec;+ for (unsigned int k=0; k<inputs.size(); k++){+ vec.push_back( Marshaling< std::vector< T1 >, std::vector< T2*> &>::marshal(inputs[k]) );+ }+ return vec;+ }+};+// pointer to ref+template<class T1, class T2>+class Marshaling< std::vector< std::vector< T1 > >,std::vector< std::vector< T2*> > *> {+ public:+ static std::vector< std::vector< T1 > > marshal(const std::vector< std::vector< T2* > > * inputs){+ return Marshaling< std::vector< std::vector< T1 > >,std::vector< std::vector< T2*> > & >::marshal(*inputs);+ }+};++template<class T1, class T2>+class Marshaling< const std::vector< std::vector< T1 > >,const std::vector< std::vector< T2* > > & > {+ public:+ static const std::vector< std::vector< T1 > > marshal(const std::vector< std::vector< T2*> > & inputs){+ std::vector< std::vector< T1 > > vec;+ for (unsigned int k=0; k<inputs.size(); k++){+ vec.push_back( Marshaling< const std::vector< T1 >, const std::vector< T2* > &>::marshal(inputs[k]) );+ }+ return vec;+ }+};+// pointer to ref+template<class T1, class T2>+class Marshaling< const std::vector< std::vector< T1 > >,const std::vector< std::vector< T2*> > *> {+ public:+ static const std::vector< std::vector< T1 > > marshal(const std::vector< std::vector< T2* > > * inputs){+ return Marshaling< const std::vector< std::vector< T1 > >,const std::vector< std::vector< T2*> > & >::marshal(*inputs);+ }+};++#endif // __MARSHAL_THEM_BINDINGS_H__