diff --git a/Casadi/Callback.hs b/Casadi/Callback.hs new file mode 100644 --- /dev/null +++ b/Casadi/Callback.hs @@ -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 diff --git a/Casadi/Marshal.hs b/Casadi/Marshal.hs new file mode 100644 --- /dev/null +++ b/Casadi/Marshal.hs @@ -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 diff --git a/Casadi/MarshalTypes.hs b/Casadi/MarshalTypes.hs new file mode 100644 --- /dev/null +++ b/Casadi/MarshalTypes.hs @@ -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 diff --git a/Casadi/WrapReturn.hs b/Casadi/WrapReturn.hs new file mode 100644 --- /dev/null +++ b/Casadi/WrapReturn.hs @@ -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) diff --git a/Casadi/Wrappers/Classes/CRSSparsity.hs b/Casadi/Wrappers/Classes/CRSSparsity.hs new file mode 100644 --- /dev/null +++ b/Casadi/Wrappers/Classes/CRSSparsity.hs @@ -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 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' + diff --git a/Casadi/Wrappers/Classes/CSparse.hs b/Casadi/Wrappers/Classes/CSparse.hs new file mode 100644 --- /dev/null +++ b/Casadi/Wrappers/Classes/CSparse.hs @@ -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'' + diff --git a/Casadi/Wrappers/Classes/Callback.hs b/Casadi/Wrappers/Classes/Callback.hs new file mode 100644 --- /dev/null +++ b/Casadi/Wrappers/Classes/Callback.hs @@ -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 + diff --git a/Casadi/Wrappers/Classes/CasadiMeta.hs b/Casadi/Wrappers/Classes/CasadiMeta.hs new file mode 100644 --- /dev/null +++ b/Casadi/Wrappers/Classes/CasadiMeta.hs @@ -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 + diff --git a/Casadi/Wrappers/Classes/CasadiOptions.hs b/Casadi/Wrappers/Classes/CasadiOptions.hs new file mode 100644 --- /dev/null +++ b/Casadi/Wrappers/Classes/CasadiOptions.hs @@ -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 + diff --git a/Casadi/Wrappers/Classes/CustomEvaluate.hs b/Casadi/Wrappers/Classes/CustomEvaluate.hs new file mode 100644 --- /dev/null +++ b/Casadi/Wrappers/Classes/CustomEvaluate.hs @@ -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 + diff --git a/Casadi/Wrappers/Classes/CustomFunction.hs b/Casadi/Wrappers/Classes/CustomFunction.hs new file mode 100644 --- /dev/null +++ b/Casadi/Wrappers/Classes/CustomFunction.hs @@ -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''''' + diff --git a/Casadi/Wrappers/Classes/DMatrix.hs b/Casadi/Wrappers/Classes/DMatrix.hs new file mode 100644 --- /dev/null +++ b/Casadi/Wrappers/Classes/DMatrix.hs @@ -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'''''''''''' + diff --git a/Casadi/Wrappers/Classes/ExternalFunction.hs b/Casadi/Wrappers/Classes/ExternalFunction.hs new file mode 100644 --- /dev/null +++ b/Casadi/Wrappers/Classes/ExternalFunction.hs @@ -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' + diff --git a/Casadi/Wrappers/Classes/FX.hs b/Casadi/Wrappers/Classes/FX.hs new file mode 100644 --- /dev/null +++ b/Casadi/Wrappers/Classes/FX.hs @@ -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 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 > 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 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 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) + diff --git a/Casadi/Wrappers/Classes/Functor.hs b/Casadi/Wrappers/Classes/Functor.hs new file mode 100644 --- /dev/null +++ b/Casadi/Wrappers/Classes/Functor.hs @@ -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 diff --git a/Casadi/Wrappers/Classes/GenericType.hs b/Casadi/Wrappers/Classes/GenericType.hs new file mode 100644 --- /dev/null +++ b/Casadi/Wrappers/Classes/GenericType.hs @@ -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 + diff --git a/Casadi/Wrappers/Classes/IOInterfaceFX.hs b/Casadi/Wrappers/Classes/IOInterfaceFX.hs new file mode 100644 --- /dev/null +++ b/Casadi/Wrappers/Classes/IOInterfaceFX.hs @@ -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&, Matrix & 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&, Matrix & 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) + diff --git a/Casadi/Wrappers/Classes/IOScheme.hs b/Casadi/Wrappers/Classes/IOScheme.hs new file mode 100644 --- /dev/null +++ b/Casadi/Wrappers/Classes/IOScheme.hs @@ -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'' + diff --git a/Casadi/Wrappers/Classes/IpoptSolver.hs b/Casadi/Wrappers/Classes/IpoptSolver.hs new file mode 100644 --- /dev/null +++ b/Casadi/Wrappers/Classes/IpoptSolver.hs @@ -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'' + diff --git a/Casadi/Wrappers/Classes/MX.hs b/Casadi/Wrappers/Classes/MX.hs new file mode 100644 --- /dev/null +++ b/Casadi/Wrappers/Classes/MX.hs @@ -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'''''''''''' + diff --git a/Casadi/Wrappers/Classes/MXFunction.hs b/Casadi/Wrappers/Classes/MXFunction.hs new file mode 100644 --- /dev/null +++ b/Casadi/Wrappers/Classes/MXFunction.hs @@ -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 + diff --git a/Casadi/Wrappers/Classes/OptionsFunctionality.hs b/Casadi/Wrappers/Classes/OptionsFunctionality.hs new file mode 100644 --- /dev/null +++ b/Casadi/Wrappers/Classes/OptionsFunctionality.hs @@ -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 + diff --git a/Casadi/Wrappers/Classes/PrintableObject.hs b/Casadi/Wrappers/Classes/PrintableObject.hs new file mode 100644 --- /dev/null +++ b/Casadi/Wrappers/Classes/PrintableObject.hs @@ -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) + diff --git a/Casadi/Wrappers/Classes/SX.hs b/Casadi/Wrappers/Classes/SX.hs new file mode 100644 --- /dev/null +++ b/Casadi/Wrappers/Classes/SX.hs @@ -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'' + diff --git a/Casadi/Wrappers/Classes/SXFunction.hs b/Casadi/Wrappers/Classes/SXFunction.hs new file mode 100644 --- /dev/null +++ b/Casadi/Wrappers/Classes/SXFunction.hs @@ -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''' + diff --git a/Casadi/Wrappers/Classes/SXMatrix.hs b/Casadi/Wrappers/Classes/SXMatrix.hs new file mode 100644 --- /dev/null +++ b/Casadi/Wrappers/Classes/SXMatrix.hs @@ -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'''''''''''' + diff --git a/Casadi/Wrappers/Classes/SharedObject.hs b/Casadi/Wrappers/Classes/SharedObject.hs new file mode 100644 --- /dev/null +++ b/Casadi/Wrappers/Classes/SharedObject.hs @@ -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) + diff --git a/Casadi/Wrappers/Data.hs b/Casadi/Wrappers/Data.hs new file mode 100644 --- /dev/null +++ b/Casadi/Wrappers/Data.hs @@ -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(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 is polymorphic with a std::vector 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 is polymorphic with a std::vector 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 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 + + diff --git a/Casadi/Wrappers/Deleters.hs b/Casadi/Wrappers/Deleters.hs new file mode 100644 --- /dev/null +++ b/Casadi/Wrappers/Deleters.hs @@ -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 ()) diff --git a/Casadi/Wrappers/Enums.hs b/Casadi/Wrappers/Enums.hs new file mode 100644 --- /dev/null +++ b/Casadi/Wrappers/Enums.hs @@ -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 + diff --git a/Casadi/Wrappers/ForeignToolsImports.hs b/Casadi/Wrappers/ForeignToolsImports.hs new file mode 100644 --- /dev/null +++ b/Casadi/Wrappers/ForeignToolsImports.hs @@ -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 () diff --git a/Casadi/Wrappers/ForeignToolsInstances.hs b/Casadi/Wrappers/ForeignToolsInstances.hs new file mode 100644 --- /dev/null +++ b/Casadi/Wrappers/ForeignToolsInstances.hs @@ -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) diff --git a/Casadi/Wrappers/Tools.hs b/Casadi/Wrappers/Tools.hs new file mode 100644 --- /dev/null +++ b/Casadi/Wrappers/Tools.hs @@ -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 + diff --git a/LICENSE b/LICENSE new file mode 100644 --- /dev/null +++ b/LICENSE @@ -0,0 +1,165 @@ + GNU LESSER GENERAL PUBLIC LICENSE + Version 3, 29 June 2007 + + Copyright (C) 2007 Free Software Foundation, Inc. + 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. diff --git a/Setup.hs b/Setup.hs new file mode 100644 --- /dev/null +++ b/Setup.hs @@ -0,0 +1,2 @@ +import Distribution.Simple +main = defaultMainWithHooks simpleUserHooks diff --git a/casadi-bindings.cabal b/casadi-bindings.cabal new file mode 100644 --- /dev/null +++ b/casadi-bindings.cabal @@ -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 diff --git a/cbits/autogen/all.cpp b/cbits/autogen/all.cpp new file mode 100644 --- /dev/null +++ b/cbits/autogen/all.cpp @@ -0,0 +1,22239 @@ +#include +#include "../marshal.hpp" +#include +#include +// ================== 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* obj); +void delete_std__vector_CasADi__SXFunction_(std::vector* obj){ + delete obj; +} +extern "C" + void delete_std__vector_std__vector_CasADi__SXFunction__(std::vector >* obj); +void delete_std__vector_std__vector_CasADi__SXFunction__(std::vector >* obj){ + delete obj; +} +extern "C" + void delete_std__vector_std__vector_std__vector_CasADi__SXFunction___(std::vector > >* obj); +void delete_std__vector_std__vector_std__vector_CasADi__SXFunction___(std::vector > >* 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::marshal(x0); + int x1_ = Marshaling::marshal(x1); + bool x2_ = Marshaling::marshal(x2); + bool x3_ = Marshaling::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::marshal(x0); + int x1_ = Marshaling::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::marshal(x0); + int x1_ = Marshaling::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::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::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::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*" +// proto: "std::vector* CasADi__SXFunction__getFree(CasADi::SXFunction* obj)" +// call: "obj->getFree()" +extern "C" + std::vector* CasADi__SXFunction__getFree(CasADi::SXFunction* obj); +std::vector* CasADi__SXFunction__getFree(CasADi::SXFunction* obj){ + + return new std::vector( 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::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::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::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::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* > * x0, std::vector* > * x1)" +// args: "(x0_, x1_)" +// rettype: Val (NonVec (CasadiClass SXFunction)) +// cWrapperRetType: "CasADi::SXFunction*" +// proto: "CasADi::SXFunction* CasADi__SXFunction__SXFunction_TIC_TIC_TIC(std::vector* > * x0, std::vector* > * x1)" +// call: "CasADi::SXFunction(x0_, x1_)" +extern "C" + CasADi::SXFunction* CasADi__SXFunction__SXFunction_TIC_TIC_TIC(std::vector* > * x0, std::vector* > * x1); +CasADi::SXFunction* CasADi__SXFunction__SXFunction_TIC_TIC_TIC(std::vector* > * x0, std::vector* > * x1){ + std::vector > x0_ = Marshaling >,std::vector* > *>::marshal(x0); + std::vector > x1_ = Marshaling >,std::vector* > *>::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* obj); +void delete_std__vector_CasADi__MXFunction_(std::vector* obj){ + delete obj; +} +extern "C" + void delete_std__vector_std__vector_CasADi__MXFunction__(std::vector >* obj); +void delete_std__vector_std__vector_CasADi__MXFunction__(std::vector >* obj){ + delete obj; +} +extern "C" + void delete_std__vector_std__vector_std__vector_CasADi__MXFunction___(std::vector > >* obj); +void delete_std__vector_std__vector_std__vector_CasADi__MXFunction___(std::vector > >* 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::marshal(x0); + int x1_ = Marshaling::marshal(x1); + bool x2_ = Marshaling::marshal(x2); + bool x3_ = Marshaling::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::marshal(x0); + int x1_ = Marshaling::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*" +// proto: "std::vector* CasADi__MXFunction__getFree(CasADi::MXFunction* obj)" +// call: "obj->getFree()" +extern "C" + std::vector* CasADi__MXFunction__getFree(CasADi::MXFunction* obj); +std::vector* CasADi__MXFunction__getFree(CasADi::MXFunction* obj){ + + return new std::vector( 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::marshal(x0); + CasADi::MXFunction x1_ = Marshaling::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::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 * x0, std::vector * x1)" +// args: "(x0_, x1_)" +// rettype: Val (NonVec (CasadiClass MXFunction)) +// cWrapperRetType: "CasADi::MXFunction*" +// proto: "CasADi::MXFunction* CasADi__MXFunction__MXFunction(std::vector * x0, std::vector * x1)" +// call: "CasADi::MXFunction(x0_, x1_)" +extern "C" + CasADi::MXFunction* CasADi__MXFunction__MXFunction(std::vector * x0, std::vector * x1); +CasADi::MXFunction* CasADi__MXFunction__MXFunction(std::vector * x0, std::vector * x1){ + std::vector x0_ = Marshaling,std::vector *>::marshal(x0); + std::vector x1_ = Marshaling,std::vector *>::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* obj); +void delete_std__vector_CasADi__FX_(std::vector* obj){ + delete obj; +} +extern "C" + void delete_std__vector_std__vector_CasADi__FX__(std::vector >* obj); +void delete_std__vector_std__vector_CasADi__FX__(std::vector >* obj){ + delete obj; +} +extern "C" + void delete_std__vector_std__vector_std__vector_CasADi__FX___(std::vector > >* obj); +void delete_std__vector_std__vector_std__vector_CasADi__FX___(std::vector > >* 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::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::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::marshal(x0); + int x1_ = Marshaling::marshal(x1); + bool x2_ = Marshaling::marshal(x2); + bool x3_ = Marshaling::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::marshal(x0); + int x1_ = Marshaling::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::marshal(x0); + int x1_ = Marshaling::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 * x0)" +// args: "(x0_)" +// rettype: Val (Vec (NonVec (CasadiClass MX))) +// cWrapperRetType: "std::vector*" +// proto: "std::vector* CasADi__FX__call(CasADi::FX* obj, std::vector * x0)" +// call: "obj->call(x0_)" +extern "C" + std::vector* CasADi__FX__call(CasADi::FX* obj, std::vector * x0); +std::vector* CasADi__FX__call(CasADi::FX* obj, std::vector * x0){ + std::vector x0_ = Marshaling,std::vector *>::marshal(x0); + + return new std::vector( 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 > * x0)" +// args: "(x0_)" +// rettype: Val (Vec (Vec (NonVec (CasadiClass MX)))) +// cWrapperRetType: "std::vector >*" +// proto: "std::vector >* CasADi__FX__call_TIC_TIC(CasADi::FX* obj, std::vector > * x0)" +// call: "obj->call(x0_)" +extern "C" + std::vector >* CasADi__FX__call_TIC_TIC(CasADi::FX* obj, std::vector > * x0); +std::vector >* CasADi__FX__call_TIC_TIC(CasADi::FX* obj, std::vector > * x0){ + std::vector > x0_ = Marshaling >,std::vector > *>::marshal(x0); + + return new std::vector >( obj->call(x0_) ); +} + + +// ================== Normal method: "evalMX" =============== +// class: "CasADi::FX" +// cppName: "CasADi::FX::evalMX" +// cWrapperName: "CasADi__FX__evalMX" +// protoArgs: "(CasADi::FX* obj, std::vector * x0)" +// args: "(x0_)" +// rettype: Val (Vec (NonVec (CasadiClass MX))) +// cWrapperRetType: "std::vector*" +// proto: "std::vector* CasADi__FX__evalMX(CasADi::FX* obj, std::vector * x0)" +// call: "obj->evalMX(x0_)" +extern "C" + std::vector* CasADi__FX__evalMX(CasADi::FX* obj, std::vector * x0); +std::vector* CasADi__FX__evalMX(CasADi::FX* obj, std::vector * x0){ + std::vector x0_ = Marshaling,std::vector *>::marshal(x0); + + return new std::vector( obj->evalMX(x0_) ); +} + + +// ================== Normal method: "evalSX" =============== +// class: "CasADi::FX" +// cppName: "CasADi::FX::evalSX" +// cWrapperName: "CasADi__FX__evalSX" +// protoArgs: "(CasADi::FX* obj, std::vector* > * x0)" +// args: "(x0_)" +// rettype: Val (Vec (NonVec (CasadiClass SXMatrix))) +// cWrapperRetType: "std::vector >*" +// proto: "std::vector >* CasADi__FX__evalSX(CasADi::FX* obj, std::vector* > * x0)" +// call: "obj->evalSX(x0_)" +extern "C" + std::vector >* CasADi__FX__evalSX(CasADi::FX* obj, std::vector* > * x0); +std::vector >* CasADi__FX__evalSX(CasADi::FX* obj, std::vector* > * x0){ + std::vector > x0_ = Marshaling >,std::vector* > *>::marshal(x0); + + return new std::vector >( 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::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::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*" +// proto: "std::vector* CasADi__FX__symbolicInput(CasADi::FX* obj)" +// call: "obj->symbolicInput()" +extern "C" + std::vector* CasADi__FX__symbolicInput(CasADi::FX* obj); +std::vector* CasADi__FX__symbolicInput(CasADi::FX* obj){ + + return new std::vector( 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 >*" +// proto: "std::vector >* CasADi__FX__symbolicInputSX(CasADi::FX* obj)" +// call: "obj->symbolicInputSX()" +extern "C" + std::vector >* CasADi__FX__symbolicInputSX(CasADi::FX* obj); +std::vector >* CasADi__FX__symbolicInputSX(CasADi::FX* obj){ + + return new std::vector >( 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::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::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* obj); +void delete_std__vector_CasADi__SharedObject_(std::vector* obj){ + delete obj; +} +extern "C" + void delete_std__vector_std__vector_CasADi__SharedObject__(std::vector >* obj); +void delete_std__vector_std__vector_CasADi__SharedObject__(std::vector >* obj){ + delete obj; +} +extern "C" + void delete_std__vector_std__vector_std__vector_CasADi__SharedObject___(std::vector > >* obj); +void delete_std__vector_std__vector_std__vector_CasADi__SharedObject___(std::vector > >* 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::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* obj); +void delete_std__vector_CasADi__PrintableObject_(std::vector* obj){ + delete obj; +} +extern "C" + void delete_std__vector_std__vector_CasADi__PrintableObject__(std::vector >* obj); +void delete_std__vector_std__vector_CasADi__PrintableObject__(std::vector >* obj){ + delete obj; +} +extern "C" + void delete_std__vector_std__vector_std__vector_CasADi__PrintableObject___(std::vector > >* obj); +void delete_std__vector_std__vector_std__vector_CasADi__PrintableObject___(std::vector > >* 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* obj); +void delete_std__vector_CasADi__CRSSparsity_(std::vector* obj){ + delete obj; +} +extern "C" + void delete_std__vector_std__vector_CasADi__CRSSparsity__(std::vector >* obj); +void delete_std__vector_std__vector_CasADi__CRSSparsity__(std::vector >* obj){ + delete obj; +} +extern "C" + void delete_std__vector_std__vector_std__vector_CasADi__CRSSparsity___(std::vector > >* obj); +void delete_std__vector_std__vector_std__vector_CasADi__CRSSparsity___(std::vector > >* 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::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::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*" +// proto: "std::vector* CasADi__CRSSparsity__colRef(CasADi::CRSSparsity* obj)" +// call: "obj->colRef()" +extern "C" + std::vector* CasADi__CRSSparsity__colRef(CasADi::CRSSparsity* obj); +std::vector* CasADi__CRSSparsity__colRef(CasADi::CRSSparsity* obj){ + + return new std::vector( 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*" +// proto: "std::vector* CasADi__CRSSparsity__rowindRef(CasADi::CRSSparsity* obj)" +// call: "obj->rowindRef()" +extern "C" + std::vector* CasADi__CRSSparsity__rowindRef(CasADi::CRSSparsity* obj); +std::vector* CasADi__CRSSparsity__rowindRef(CasADi::CRSSparsity* obj){ + + return new std::vector( 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*" +// proto: "std::vector* CasADi__CRSSparsity__getRow(CasADi::CRSSparsity* obj)" +// call: "obj->getRow()" +extern "C" + std::vector* CasADi__CRSSparsity__getRow(CasADi::CRSSparsity* obj); +std::vector* CasADi__CRSSparsity__getRow(CasADi::CRSSparsity* obj){ + + return new std::vector( 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::marshal(x0); + int x1_ = Marshaling::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 * x0, std::vector * x1)" +// args: "(x0_, x1_)" +// rettype: Val (Vec (NonVec CInt)) +// cWrapperRetType: "std::vector*" +// proto: "std::vector* CasADi__CRSSparsity__getNZ_TIC_TIC(CasADi::CRSSparsity* obj, std::vector * x0, std::vector * x1)" +// call: "obj->getNZ(x0_, x1_)" +extern "C" + std::vector* CasADi__CRSSparsity__getNZ_TIC_TIC(CasADi::CRSSparsity* obj, std::vector * x0, std::vector * x1); +std::vector* CasADi__CRSSparsity__getNZ_TIC_TIC(CasADi::CRSSparsity* obj, std::vector * x0, std::vector * x1){ + std::vector x0_ = Marshaling,std::vector *>::marshal(x0); + std::vector x1_ = Marshaling,std::vector *>::marshal(x1); + + return new std::vector( 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::marshal(x0); + int x1_ = Marshaling::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* x0)" +// args: "(x0_)" +// rettype: Val (NonVec CVoid) +// cWrapperRetType: "void" +// proto: "void CasADi__CRSSparsity__getNZInplace(CasADi::CRSSparsity* obj, std::vector* x0)" +// call: "obj->getNZInplace(x0_)" +extern "C" + void CasADi__CRSSparsity__getNZInplace(CasADi::CRSSparsity* obj, std::vector* x0); +void CasADi__CRSSparsity__getNZInplace(CasADi::CRSSparsity* obj, std::vector* x0){ + std::vector x0_ = Marshaling,std::vector*>::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::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*" +// proto: "std::vector* CasADi__CRSSparsity__getElements(CasADi::CRSSparsity* obj, bool* x0)" +// call: "obj->getElements(x0_)" +extern "C" + std::vector* CasADi__CRSSparsity__getElements(CasADi::CRSSparsity* obj, bool* x0); +std::vector* CasADi__CRSSparsity__getElements(CasADi::CRSSparsity* obj, bool* x0){ + bool x0_ = Marshaling::marshal(x0); + + return new std::vector( 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::marshal(x0); + int x1_ = Marshaling::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::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::marshal(x0); + int x1_ = Marshaling::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::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::marshal(x0); + int x1_ = Marshaling::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::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::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 * x2, std::vector * 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 * x2, std::vector * x3)" +// call: "CasADi::CRSSparsity(x0_, x1_, x2_, x3_)" +extern "C" + CasADi::CRSSparsity* CasADi__CRSSparsity__CRSSparsity(int x0, int x1, std::vector * x2, std::vector * x3); +CasADi::CRSSparsity* CasADi__CRSSparsity__CRSSparsity(int x0, int x1, std::vector * x2, std::vector * x3){ + int x0_ = Marshaling::marshal(x0); + int x1_ = Marshaling::marshal(x1); + std::vector x2_ = Marshaling,std::vector *>::marshal(x2); + std::vector x3_ = Marshaling,std::vector *>::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* obj); +void delete_std__vector_CasADi__GenericType_(std::vector* obj){ + delete obj; +} +extern "C" + void delete_std__vector_std__vector_CasADi__GenericType__(std::vector >* obj); +void delete_std__vector_std__vector_CasADi__GenericType__(std::vector >* obj){ + delete obj; +} +extern "C" + void delete_std__vector_std__vector_std__vector_CasADi__GenericType___(std::vector > >* obj); +void delete_std__vector_std__vector_std__vector_CasADi__GenericType___(std::vector > >* 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::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::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::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::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::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::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::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::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::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::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 * x0)" +// args: "(x0_)" +// rettype: Val (NonVec (CasadiClass GenericType)) +// cWrapperRetType: "CasADi::GenericType*" +// proto: "CasADi::GenericType* CasADi__GenericType__GenericTypeBoolVec(std::vector * x0)" +// call: "CasADi::GenericType(x0_)" +extern "C" + CasADi::GenericType* CasADi__GenericType__GenericTypeBoolVec(std::vector * x0); +CasADi::GenericType* CasADi__GenericType__GenericTypeBoolVec(std::vector * x0){ + std::vector x0_ = Marshaling,std::vector *>::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 * x0)" +// args: "(x0_)" +// rettype: Val (NonVec (CasadiClass GenericType)) +// cWrapperRetType: "CasADi::GenericType*" +// proto: "CasADi::GenericType* CasADi__GenericType__GenericTypeIntVec(std::vector * x0)" +// call: "CasADi::GenericType(x0_)" +extern "C" + CasADi::GenericType* CasADi__GenericType__GenericTypeIntVec(std::vector * x0); +CasADi::GenericType* CasADi__GenericType__GenericTypeIntVec(std::vector * x0){ + std::vector x0_ = Marshaling,std::vector *>::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 * x0)" +// args: "(x0_)" +// rettype: Val (NonVec (CasadiClass GenericType)) +// cWrapperRetType: "CasADi::GenericType*" +// proto: "CasADi::GenericType* CasADi__GenericType__GenericTypeDoubleVec(std::vector * x0)" +// call: "CasADi::GenericType(x0_)" +extern "C" + CasADi::GenericType* CasADi__GenericType__GenericTypeDoubleVec(std::vector * x0); +CasADi::GenericType* CasADi__GenericType__GenericTypeDoubleVec(std::vector * x0){ + std::vector x0_ = Marshaling,std::vector *>::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 * x0)" +// args: "(x0_)" +// rettype: Val (NonVec (CasadiClass GenericType)) +// cWrapperRetType: "CasADi::GenericType*" +// proto: "CasADi::GenericType* CasADi__GenericType__GenericTypeStringVec(std::vector * x0)" +// call: "CasADi::GenericType(x0_)" +extern "C" + CasADi::GenericType* CasADi__GenericType__GenericTypeStringVec(std::vector * x0); +CasADi::GenericType* CasADi__GenericType__GenericTypeStringVec(std::vector * x0){ + std::vector x0_ = Marshaling,std::vector *>::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::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::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* >* obj); +void delete_std__vector_CasADi__IOInterface_CasADi__FX__(std::vector* >* obj){ + delete obj; +} +extern "C" + void delete_std__vector_std__vector_CasADi__IOInterface_CasADi__FX___(std::vector* > >* obj); +void delete_std__vector_std__vector_CasADi__IOInterface_CasADi__FX___(std::vector* > >* obj){ + delete obj; +} +extern "C" + void delete_std__vector_std__vector_std__vector_CasADi__IOInterface_CasADi__FX____(std::vector* > > >* obj); +void delete_std__vector_std__vector_std__vector_CasADi__IOInterface_CasADi__FX____(std::vector* > > >* 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::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::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::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::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::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::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::marshal(x0); + std::string x1_ = Marshaling::marshal(x1); + bool x2_ = Marshaling::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::marshal(x0); + int x1_ = Marshaling::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::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::marshal(x0); + int x1_ = Marshaling::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::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::marshal(x0); + std::string x1_ = Marshaling::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 * 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 * 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 * x0, int x1); +void CasADi__IOInterface_CasADi__FX___setInput_TIC_TIC_TIC(CasADi::IOInterface< CasADi::FX >* obj, std::vector * x0, int x1){ + std::vector x0_ = Marshaling,std::vector *>::marshal(x0); + int x1_ = Marshaling::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 * 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 * x0)" +// call: "obj->setInput(x0_)" +extern "C" + void CasADi__IOInterface_CasADi__FX___setInput_TIC_TIC_TIC_TIC(CasADi::IOInterface< CasADi::FX >* obj, std::vector * x0); +void CasADi__IOInterface_CasADi__FX___setInput_TIC_TIC_TIC_TIC(CasADi::IOInterface< CasADi::FX >* obj, std::vector * x0){ + std::vector x0_ = Marshaling,std::vector *>::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 * 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 * 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 * x0, int x1); +void CasADi__IOInterface_CasADi__FX___setOutput_TIC_TIC_TIC(CasADi::IOInterface< CasADi::FX >* obj, std::vector * x0, int x1){ + std::vector x0_ = Marshaling,std::vector *>::marshal(x0); + int x1_ = Marshaling::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 * 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 * x0)" +// call: "obj->setOutput(x0_)" +extern "C" + void CasADi__IOInterface_CasADi__FX___setOutput_TIC_TIC_TIC_TIC(CasADi::IOInterface< CasADi::FX >* obj, std::vector * x0); +void CasADi__IOInterface_CasADi__FX___setOutput_TIC_TIC_TIC_TIC(CasADi::IOInterface< CasADi::FX >* obj, std::vector * x0){ + std::vector x0_ = Marshaling,std::vector *>::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 * 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 * 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 * x0, std::string* x1); +void CasADi__IOInterface_CasADi__FX___setInput_TIC_TIC_TIC_TIC_TIC(CasADi::IOInterface< CasADi::FX >* obj, std::vector * x0, std::string* x1){ + std::vector x0_ = Marshaling,std::vector *>::marshal(x0); + std::string x1_ = Marshaling::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 * 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 * 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 * x0, std::string* x1); +void CasADi__IOInterface_CasADi__FX___setOutput_TIC_TIC_TIC_TIC_TIC(CasADi::IOInterface< CasADi::FX >* obj, std::vector * x0, std::string* x1){ + std::vector x0_ = Marshaling,std::vector *>::marshal(x0); + std::string x1_ = Marshaling::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 >*>::marshal(x0); + int x1_ = Marshaling::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 >*>::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 >*>::marshal(x0); + int x1_ = Marshaling::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 >*>::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 >*>::marshal(x0); + std::string x1_ = Marshaling::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 >*>::marshal(x0); + std::string x1_ = Marshaling::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* obj); +void delete_std__vector_CasADi__OptionsFunctionality_(std::vector* obj){ + delete obj; +} +extern "C" + void delete_std__vector_std__vector_CasADi__OptionsFunctionality__(std::vector >* obj); +void delete_std__vector_std__vector_CasADi__OptionsFunctionality__(std::vector >* obj){ + delete obj; +} +extern "C" + void delete_std__vector_std__vector_std__vector_CasADi__OptionsFunctionality___(std::vector > >* obj); +void delete_std__vector_std__vector_std__vector_CasADi__OptionsFunctionality___(std::vector > >* 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::marshal(x0); + CasADi::GenericType x1_ = Marshaling::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::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::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::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::marshal(x0); + bool x1_ = Marshaling::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::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*" +// proto: "std::vector* CasADi__OptionsFunctionality__getOptionNames(CasADi::OptionsFunctionality* obj)" +// call: "obj->getOptionNames()" +extern "C" + std::vector* CasADi__OptionsFunctionality__getOptionNames(CasADi::OptionsFunctionality* obj); +std::vector* CasADi__OptionsFunctionality__getOptionNames(CasADi::OptionsFunctionality* obj){ + + return new std::vector( 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::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::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::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*" +// proto: "std::vector* CasADi__OptionsFunctionality__getOptionAllowed(CasADi::OptionsFunctionality* obj, std::string* x0)" +// call: "obj->getOptionAllowed(x0_)" +extern "C" + std::vector* CasADi__OptionsFunctionality__getOptionAllowed(CasADi::OptionsFunctionality* obj, std::string* x0); +std::vector* CasADi__OptionsFunctionality__getOptionAllowed(CasADi::OptionsFunctionality* obj, std::string* x0){ + std::string x0_ = Marshaling::marshal(x0); + + return new std::vector( 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::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::marshal(x0); + int x1_ = Marshaling::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::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::marshal(x0); + int x1_ = Marshaling::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::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* obj); +void delete_std__vector_CasADi__IpoptSolver_(std::vector* obj){ + delete obj; +} +extern "C" + void delete_std__vector_std__vector_CasADi__IpoptSolver__(std::vector >* obj); +void delete_std__vector_std__vector_CasADi__IpoptSolver__(std::vector >* obj){ + delete obj; +} +extern "C" + void delete_std__vector_std__vector_std__vector_CasADi__IpoptSolver___(std::vector > >* obj); +void delete_std__vector_std__vector_std__vector_CasADi__IpoptSolver___(std::vector > >* 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::marshal(x0); + CasADi::FX x1_ = Marshaling::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::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* >* obj); +void delete_std__vector_CasADi__Matrix_CasADi__SX__(std::vector* >* obj){ + delete obj; +} +extern "C" + void delete_std__vector_std__vector_CasADi__Matrix_CasADi__SX___(std::vector* > >* obj); +void delete_std__vector_std__vector_CasADi__Matrix_CasADi__SX___(std::vector* > >* obj){ + delete obj; +} +extern "C" + void delete_std__vector_std__vector_std__vector_CasADi__Matrix_CasADi__SX____(std::vector* > > >* obj); +void delete_std__vector_std__vector_std__vector_CasADi__Matrix_CasADi__SX____(std::vector* > > >* 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::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::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::marshal(x0); + int x1_ = Marshaling::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::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::marshal(x0); + int x1_ = Marshaling::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 >*>::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::marshal(x0); + CasADi::Matrix< CasADi::SX > x1_ = Marshaling,CasADi::Matrix< CasADi::SX >*>::marshal(x1); + CasADi::Matrix< CasADi::SX > x2_ = Marshaling,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::marshal(x0); + CasADi::Matrix< CasADi::SX > x1_ = Marshaling,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::marshal(x0); + CasADi::Matrix< CasADi::SX > x1_ = Marshaling,CasADi::Matrix< CasADi::SX >*>::marshal(x1); + CasADi::Matrix< CasADi::SX > x2_ = Marshaling,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::marshal(x0); + CasADi::Matrix< CasADi::SX > x1_ = Marshaling,CasADi::Matrix< CasADi::SX >*>::marshal(x1); + CasADi::Matrix< CasADi::SX > x2_ = Marshaling,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::marshal(x0); + CasADi::Matrix< CasADi::SX > x1_ = Marshaling,CasADi::Matrix< CasADi::SX >*>::marshal(x1); + CasADi::Matrix< CasADi::SX > x2_ = Marshaling,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 >*>::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 >*>::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 >*>::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 >*>::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 >*>::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 >*>::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 >*>::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 >*>::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 >*>::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 >*>::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 >*>::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 >*>::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 >*>::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 >*>::marshal(x0); + CasADi::CRSSparsity x1_ = Marshaling::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 >*>::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 >*>::marshal(x0); + CasADi::CRSSparsity x1_ = Marshaling::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 >*>::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 >*>::marshal(x0); + CasADi::Matrix< CasADi::SX > x1_ = Marshaling,CasADi::Matrix< CasADi::SX >*>::marshal(x1); + CasADi::Matrix< CasADi::SX > x2_ = Marshaling,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 >*>::marshal(x0); + CasADi::Matrix< CasADi::SX > x1_ = Marshaling,CasADi::Matrix< CasADi::SX >*>::marshal(x1); + CasADi::Matrix< CasADi::SX > x2_ = Marshaling,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 >*>::marshal(x0); + CasADi::Matrix< CasADi::SX > x1_ = Marshaling,CasADi::Matrix< CasADi::SX >*>::marshal(x1); + CasADi::Matrix< CasADi::SX > x2_ = Marshaling,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 * x1, std::vector* 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 * x1, std::vector* 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 * x1, std::vector* x2); +void CasADi__Matrix_CasADi__SX___mul_no_alloc_nn_TIC(CasADi::Matrix< CasADi::SX >* x0, std::vector * x1, std::vector* x2){ + CasADi::Matrix< CasADi::SX > x0_ = Marshaling,CasADi::Matrix< CasADi::SX >*>::marshal(x0); + std::vector x1_ = Marshaling,std::vector *>::marshal(x1); + std::vector x2_ = Marshaling,std::vector*>::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 * x1, std::vector* 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 * x1, std::vector* 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 * x1, std::vector* x2); +void CasADi__Matrix_CasADi__SX___mul_no_alloc_tn_TIC(CasADi::Matrix< CasADi::SX >* x0, std::vector * x1, std::vector* x2){ + CasADi::Matrix< CasADi::SX > x0_ = Marshaling,CasADi::Matrix< CasADi::SX >*>::marshal(x0); + std::vector x1_ = Marshaling,std::vector *>::marshal(x1); + std::vector x2_ = Marshaling,std::vector*>::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 * 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 * 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 * x1); +CasADi::SX* CasADi__Matrix_CasADi__SX___quad_form(CasADi::Matrix< CasADi::SX >* x0, std::vector * x1){ + CasADi::Matrix< CasADi::SX > x0_ = Marshaling,CasADi::Matrix< CasADi::SX >*>::marshal(x0); + std::vector x1_ = Marshaling,std::vector *>::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 >*>::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 >*>::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 >*>::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 >*>::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 >*>::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 >*>::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 >*>::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::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::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::marshal(x0); + int x1_ = Marshaling::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::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::marshal(x0); + int x1_ = Marshaling::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 * x0, std::vector * x1)" +// args: "(x0_, x1_)" +// rettype: Val (NonVec CVoid) +// cWrapperRetType: "void" +// proto: "void CasADi__Matrix_CasADi__SX___erase(CasADi::Matrix< CasADi::SX >* obj, std::vector * x0, std::vector * x1)" +// call: "obj->erase(x0_, x1_)" +extern "C" + void CasADi__Matrix_CasADi__SX___erase(CasADi::Matrix< CasADi::SX >* obj, std::vector * x0, std::vector * x1); +void CasADi__Matrix_CasADi__SX___erase(CasADi::Matrix< CasADi::SX >* obj, std::vector * x0, std::vector * x1){ + std::vector x0_ = Marshaling,std::vector *>::marshal(x0); + std::vector x1_ = Marshaling,std::vector *>::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 * x0, std::vector * x1)" +// args: "(x0_, x1_)" +// rettype: Val (NonVec CVoid) +// cWrapperRetType: "void" +// proto: "void CasADi__Matrix_CasADi__SX___remove(CasADi::Matrix< CasADi::SX >* obj, std::vector * x0, std::vector * x1)" +// call: "obj->remove(x0_, x1_)" +extern "C" + void CasADi__Matrix_CasADi__SX___remove(CasADi::Matrix< CasADi::SX >* obj, std::vector * x0, std::vector * x1); +void CasADi__Matrix_CasADi__SX___remove(CasADi::Matrix< CasADi::SX >* obj, std::vector * x0, std::vector * x1){ + std::vector x0_ = Marshaling,std::vector *>::marshal(x0); + std::vector x1_ = Marshaling,std::vector *>::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 * x2, std::vector * 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 * x2, std::vector * 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 * x2, std::vector * x3); +void CasADi__Matrix_CasADi__SX___enlarge(CasADi::Matrix< CasADi::SX >* obj, int x0, int x1, std::vector * x2, std::vector * x3){ + int x0_ = Marshaling::marshal(x0); + int x1_ = Marshaling::marshal(x1); + std::vector x2_ = Marshaling,std::vector *>::marshal(x2); + std::vector x3_ = Marshaling,std::vector *>::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*" +// proto: "std::vector* CasADi__Matrix_CasADi__SX___data(CasADi::Matrix< CasADi::SX >* obj)" +// call: "obj->data()" +extern "C" + std::vector* CasADi__Matrix_CasADi__SX___data(CasADi::Matrix< CasADi::SX >* obj); +std::vector* CasADi__Matrix_CasADi__SX___data(CasADi::Matrix< CasADi::SX >* obj){ + + return new std::vector( 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::marshal(x0); + CasADi::Sparsity x1_ = Marshaling::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::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::marshal(x0); + CasADi::Sparsity x1_ = Marshaling::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::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 * 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 * 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 * x0, CasADi::Sparsity x1); +void CasADi__Matrix_CasADi__SX___set_TIC_TIC(CasADi::Matrix< CasADi::SX >* obj, std::vector * x0, CasADi::Sparsity x1){ + std::vector x0_ = Marshaling,std::vector *>::marshal(x0); + CasADi::Sparsity x1_ = Marshaling::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 * 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 * x0)" +// call: "obj->set(x0_)" +extern "C" + void CasADi__Matrix_CasADi__SX___set_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* obj, std::vector * x0); +void CasADi__Matrix_CasADi__SX___set_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* obj, std::vector * x0){ + std::vector x0_ = Marshaling,std::vector *>::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* 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* 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* x0, CasADi::Sparsity x1); +void CasADi__Matrix_CasADi__SX___get_TIC_TIC(CasADi::Matrix< CasADi::SX >* obj, std::vector* x0, CasADi::Sparsity x1){ + std::vector x0_ = Marshaling,std::vector*>::marshal(x0); + CasADi::Sparsity x1_ = Marshaling::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* 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* x0)" +// call: "obj->get(x0_)" +extern "C" + void CasADi__Matrix_CasADi__SX___get_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* obj, std::vector* x0); +void CasADi__Matrix_CasADi__SX___get_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* obj, std::vector* x0){ + std::vector x0_ = Marshaling,std::vector*>::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 >*>::marshal(x0); + CasADi::Sparsity x1_ = Marshaling::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 >*>::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 >*>::marshal(x0); + CasADi::Sparsity x1_ = Marshaling::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 >*>::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::marshal(x0); + int x1_ = Marshaling::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::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 * x0, std::vector * x1, std::vector * 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 * x0, std::vector * x1, std::vector * 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 * x0, std::vector * x1, std::vector * x2); +CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___sparse_TIC_TIC(std::vector * x0, std::vector * x1, std::vector * x2){ + std::vector x0_ = Marshaling,std::vector *>::marshal(x0); + std::vector x1_ = Marshaling,std::vector *>::marshal(x1); + std::vector x2_ = Marshaling,std::vector *>::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 * x0, std::vector * x1, std::vector * 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 * x0, std::vector * x1, std::vector * 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 * x0, std::vector * x1, std::vector * x2, int x3, int x4); +CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___sparse_TIC_TIC_TIC(std::vector * x0, std::vector * x1, std::vector * x2, int x3, int x4){ + std::vector x0_ = Marshaling,std::vector *>::marshal(x0); + std::vector x1_ = Marshaling,std::vector *>::marshal(x1); + std::vector x2_ = Marshaling,std::vector *>::marshal(x2); + int x3_ = Marshaling::marshal(x3); + int x4_ = Marshaling::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::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::marshal(x0); + int x1_ = Marshaling::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::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::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::marshal(x0); + int x1_ = Marshaling::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::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::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::marshal(x0); + int x1_ = Marshaling::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::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::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::marshal(x0); + int x1_ = Marshaling::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::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 >*>::marshal(x0); + int x1_ = Marshaling::marshal(x1); + int x2_ = Marshaling::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 >*>::marshal(x0); + int x1_ = Marshaling::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::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::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::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::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 >*>::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::marshal(x0); + int x1_ = Marshaling::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::marshal(x0); + int x1_ = Marshaling::marshal(x1); + CasADi::SX x2_ = Marshaling::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 * x2, std::vector * x3, std::vector * 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 * x2, std::vector * x3, std::vector * 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 * x2, std::vector * x3, std::vector * x4); +CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC(int x0, int x1, std::vector * x2, std::vector * x3, std::vector * x4){ + int x0_ = Marshaling::marshal(x0); + int x1_ = Marshaling::marshal(x1); + std::vector x2_ = Marshaling,std::vector *>::marshal(x2); + std::vector x3_ = Marshaling,std::vector *>::marshal(x3); + std::vector x4_ = Marshaling,std::vector *>::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 * x2, std::vector * 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 * x2, std::vector * 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 * x2, std::vector * x3); +CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC(int x0, int x1, std::vector * x2, std::vector * x3){ + int x0_ = Marshaling::marshal(x0); + int x1_ = Marshaling::marshal(x1); + std::vector x2_ = Marshaling,std::vector *>::marshal(x2); + std::vector x3_ = Marshaling,std::vector *>::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 > * 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 > * 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 > * x0); +CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC_TIC(std::vector > * x0){ + std::vector > x0_ = Marshaling >,std::vector > *>::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::marshal(x0); + CasADi::SX x1_ = Marshaling::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::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 * 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 * 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 * x1); +CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::CRSSparsity* x0, std::vector * x1){ + CasADi::CRSSparsity x0_ = Marshaling::marshal(x0); + std::vector x1_ = Marshaling,std::vector *>::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::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 * 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 * 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 * x0); +CasADi::Matrix< CasADi::SX >* CasADi__Matrix_CasADi__SX___SXMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector * x0){ + std::vector x0_ = Marshaling,std::vector *>::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 * 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 * 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 * 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 * x0, int x1, int x2){ + std::vector x0_ = Marshaling,std::vector *>::marshal(x0); + int x1_ = Marshaling::marshal(x1); + int x2_ = Marshaling::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* obj); +void delete_std__vector_CasADi__IOScheme_(std::vector* obj){ + delete obj; +} +extern "C" + void delete_std__vector_std__vector_CasADi__IOScheme__(std::vector >* obj); +void delete_std__vector_std__vector_CasADi__IOScheme__(std::vector >* obj){ + delete obj; +} +extern "C" + void delete_std__vector_std__vector_std__vector_CasADi__IOScheme___(std::vector > >* obj); +void delete_std__vector_std__vector_std__vector_CasADi__IOScheme___(std::vector > >* 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::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::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::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::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::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::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::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::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::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 * x0)" +// args: "(x0_)" +// rettype: Val (NonVec (CasadiClass IOScheme)) +// cWrapperRetType: "CasADi::IOScheme*" +// proto: "CasADi::IOScheme* CasADi__IOScheme__IOScheme_TIC_TIC(std::vector * x0)" +// call: "CasADi::IOScheme(x0_)" +extern "C" + CasADi::IOScheme* CasADi__IOScheme__IOScheme_TIC_TIC(std::vector * x0); +CasADi::IOScheme* CasADi__IOScheme__IOScheme_TIC_TIC(std::vector * x0){ + std::vector x0_ = Marshaling,std::vector *>::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* >* obj); +void delete_std__vector_CasADi__Matrix_double__(std::vector* >* obj){ + delete obj; +} +extern "C" + void delete_std__vector_std__vector_CasADi__Matrix_double___(std::vector* > >* obj); +void delete_std__vector_std__vector_CasADi__Matrix_double___(std::vector* > >* obj){ + delete obj; +} +extern "C" + void delete_std__vector_std__vector_std__vector_CasADi__Matrix_double____(std::vector* > > >* obj); +void delete_std__vector_std__vector_std__vector_CasADi__Matrix_double____(std::vector* > > >* 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::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::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::marshal(x0); + int x1_ = Marshaling::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::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::marshal(x0); + int x1_ = Marshaling::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 >*>::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::marshal(x0); + CasADi::Matrix< double > x1_ = Marshaling,CasADi::Matrix< double >*>::marshal(x1); + CasADi::Matrix< double > x2_ = Marshaling,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::marshal(x0); + CasADi::Matrix< double > x1_ = Marshaling,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::marshal(x0); + CasADi::Matrix< double > x1_ = Marshaling,CasADi::Matrix< double >*>::marshal(x1); + CasADi::Matrix< double > x2_ = Marshaling,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::marshal(x0); + CasADi::Matrix< double > x1_ = Marshaling,CasADi::Matrix< double >*>::marshal(x1); + CasADi::Matrix< double > x2_ = Marshaling,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::marshal(x0); + CasADi::Matrix< double > x1_ = Marshaling,CasADi::Matrix< double >*>::marshal(x1); + CasADi::Matrix< double > x2_ = Marshaling,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 >*>::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 >*>::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 >*>::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 >*>::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 >*>::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 >*>::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 >*>::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 >*>::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 >*>::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 >*>::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 >*>::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 >*>::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 >*>::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 >*>::marshal(x0); + CasADi::CRSSparsity x1_ = Marshaling::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 >*>::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 >*>::marshal(x0); + CasADi::CRSSparsity x1_ = Marshaling::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 >*>::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 >*>::marshal(x0); + CasADi::Matrix< double > x1_ = Marshaling,CasADi::Matrix< double >*>::marshal(x1); + CasADi::Matrix< double > x2_ = Marshaling,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 >*>::marshal(x0); + CasADi::Matrix< double > x1_ = Marshaling,CasADi::Matrix< double >*>::marshal(x1); + CasADi::Matrix< double > x2_ = Marshaling,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 >*>::marshal(x0); + CasADi::Matrix< double > x1_ = Marshaling,CasADi::Matrix< double >*>::marshal(x1); + CasADi::Matrix< double > x2_ = Marshaling,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 * x1, std::vector* 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 * x1, std::vector* 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 * x1, std::vector* x2); +void CasADi__Matrix_double___mul_no_alloc_nn_TIC(CasADi::Matrix< double >* x0, std::vector * x1, std::vector* x2){ + CasADi::Matrix< double > x0_ = Marshaling,CasADi::Matrix< double >*>::marshal(x0); + std::vector x1_ = Marshaling,std::vector *>::marshal(x1); + std::vector x2_ = Marshaling,std::vector*>::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 * x1, std::vector* 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 * x1, std::vector* 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 * x1, std::vector* x2); +void CasADi__Matrix_double___mul_no_alloc_tn_TIC(CasADi::Matrix< double >* x0, std::vector * x1, std::vector* x2){ + CasADi::Matrix< double > x0_ = Marshaling,CasADi::Matrix< double >*>::marshal(x0); + std::vector x1_ = Marshaling,std::vector *>::marshal(x1); + std::vector x2_ = Marshaling,std::vector*>::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 * x1)" +// args: "(x0_, x1_)" +// rettype: Val (NonVec CDouble) +// cWrapperRetType: "double" +// proto: "double CasADi__Matrix_double___quad_form(CasADi::Matrix< double >* x0, std::vector * x1)" +// call: "CasADi::Matrix< double >::quad_form(x0_, x1_)" +extern "C" + double CasADi__Matrix_double___quad_form(CasADi::Matrix< double >* x0, std::vector * x1); +double CasADi__Matrix_double___quad_form(CasADi::Matrix< double >* x0, std::vector * x1){ + CasADi::Matrix< double > x0_ = Marshaling,CasADi::Matrix< double >*>::marshal(x0); + std::vector x1_ = Marshaling,std::vector *>::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 >*>::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 >*>::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 >*>::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 >*>::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 >*>::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 >*>::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 >*>::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::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::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::marshal(x0); + int x1_ = Marshaling::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::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::marshal(x0); + int x1_ = Marshaling::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 * x0, std::vector * x1)" +// args: "(x0_, x1_)" +// rettype: Val (NonVec CVoid) +// cWrapperRetType: "void" +// proto: "void CasADi__Matrix_double___erase(CasADi::Matrix< double >* obj, std::vector * x0, std::vector * x1)" +// call: "obj->erase(x0_, x1_)" +extern "C" + void CasADi__Matrix_double___erase(CasADi::Matrix< double >* obj, std::vector * x0, std::vector * x1); +void CasADi__Matrix_double___erase(CasADi::Matrix< double >* obj, std::vector * x0, std::vector * x1){ + std::vector x0_ = Marshaling,std::vector *>::marshal(x0); + std::vector x1_ = Marshaling,std::vector *>::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 * x0, std::vector * x1)" +// args: "(x0_, x1_)" +// rettype: Val (NonVec CVoid) +// cWrapperRetType: "void" +// proto: "void CasADi__Matrix_double___remove(CasADi::Matrix< double >* obj, std::vector * x0, std::vector * x1)" +// call: "obj->remove(x0_, x1_)" +extern "C" + void CasADi__Matrix_double___remove(CasADi::Matrix< double >* obj, std::vector * x0, std::vector * x1); +void CasADi__Matrix_double___remove(CasADi::Matrix< double >* obj, std::vector * x0, std::vector * x1){ + std::vector x0_ = Marshaling,std::vector *>::marshal(x0); + std::vector x1_ = Marshaling,std::vector *>::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 * x2, std::vector * 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 * x2, std::vector * 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 * x2, std::vector * x3); +void CasADi__Matrix_double___enlarge(CasADi::Matrix< double >* obj, int x0, int x1, std::vector * x2, std::vector * x3){ + int x0_ = Marshaling::marshal(x0); + int x1_ = Marshaling::marshal(x1); + std::vector x2_ = Marshaling,std::vector *>::marshal(x2); + std::vector x3_ = Marshaling,std::vector *>::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*" +// proto: "std::vector* CasADi__Matrix_double___data(CasADi::Matrix< double >* obj)" +// call: "obj->data()" +extern "C" + std::vector* CasADi__Matrix_double___data(CasADi::Matrix< double >* obj); +std::vector* CasADi__Matrix_double___data(CasADi::Matrix< double >* obj){ + + return new std::vector( 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::marshal(x0); + CasADi::Sparsity x1_ = Marshaling::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::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::marshal(x0); + CasADi::Sparsity x1_ = Marshaling::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::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 * 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 * x0, CasADi::Sparsity x1)" +// call: "obj->set(x0_, x1_)" +extern "C" + void CasADi__Matrix_double___set_TIC_TIC(CasADi::Matrix< double >* obj, std::vector * x0, CasADi::Sparsity x1); +void CasADi__Matrix_double___set_TIC_TIC(CasADi::Matrix< double >* obj, std::vector * x0, CasADi::Sparsity x1){ + std::vector x0_ = Marshaling,std::vector *>::marshal(x0); + CasADi::Sparsity x1_ = Marshaling::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 * x0)" +// args: "(x0_)" +// rettype: Val (NonVec CVoid) +// cWrapperRetType: "void" +// proto: "void CasADi__Matrix_double___set_TIC_TIC_TIC(CasADi::Matrix< double >* obj, std::vector * x0)" +// call: "obj->set(x0_)" +extern "C" + void CasADi__Matrix_double___set_TIC_TIC_TIC(CasADi::Matrix< double >* obj, std::vector * x0); +void CasADi__Matrix_double___set_TIC_TIC_TIC(CasADi::Matrix< double >* obj, std::vector * x0){ + std::vector x0_ = Marshaling,std::vector *>::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* 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* x0, CasADi::Sparsity x1)" +// call: "obj->get(x0_, x1_)" +extern "C" + void CasADi__Matrix_double___get_TIC_TIC(CasADi::Matrix< double >* obj, std::vector* x0, CasADi::Sparsity x1); +void CasADi__Matrix_double___get_TIC_TIC(CasADi::Matrix< double >* obj, std::vector* x0, CasADi::Sparsity x1){ + std::vector x0_ = Marshaling,std::vector*>::marshal(x0); + CasADi::Sparsity x1_ = Marshaling::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* x0)" +// args: "(x0_)" +// rettype: Val (NonVec CVoid) +// cWrapperRetType: "void" +// proto: "void CasADi__Matrix_double___get_TIC_TIC_TIC(CasADi::Matrix< double >* obj, std::vector* x0)" +// call: "obj->get(x0_)" +extern "C" + void CasADi__Matrix_double___get_TIC_TIC_TIC(CasADi::Matrix< double >* obj, std::vector* x0); +void CasADi__Matrix_double___get_TIC_TIC_TIC(CasADi::Matrix< double >* obj, std::vector* x0){ + std::vector x0_ = Marshaling,std::vector*>::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 >*>::marshal(x0); + CasADi::Sparsity x1_ = Marshaling::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 >*>::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 >*>::marshal(x0); + CasADi::Sparsity x1_ = Marshaling::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 >*>::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::marshal(x0); + int x1_ = Marshaling::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::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 * x0, std::vector * x1, std::vector * 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 * x0, std::vector * x1, std::vector * x2)" +// call: "CasADi::Matrix< double >::sparse(x0_, x1_, x2_)" +extern "C" + CasADi::Matrix< double >* CasADi__Matrix_double___sparse_TIC_TIC(std::vector * x0, std::vector * x1, std::vector * x2); +CasADi::Matrix< double >* CasADi__Matrix_double___sparse_TIC_TIC(std::vector * x0, std::vector * x1, std::vector * x2){ + std::vector x0_ = Marshaling,std::vector *>::marshal(x0); + std::vector x1_ = Marshaling,std::vector *>::marshal(x1); + std::vector x2_ = Marshaling,std::vector *>::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 * x0, std::vector * x1, std::vector * 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 * x0, std::vector * x1, std::vector * 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 * x0, std::vector * x1, std::vector * x2, int x3, int x4); +CasADi::Matrix< double >* CasADi__Matrix_double___sparse_TIC_TIC_TIC(std::vector * x0, std::vector * x1, std::vector * x2, int x3, int x4){ + std::vector x0_ = Marshaling,std::vector *>::marshal(x0); + std::vector x1_ = Marshaling,std::vector *>::marshal(x1); + std::vector x2_ = Marshaling,std::vector *>::marshal(x2); + int x3_ = Marshaling::marshal(x3); + int x4_ = Marshaling::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::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::marshal(x0); + int x1_ = Marshaling::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::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::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::marshal(x0); + int x1_ = Marshaling::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::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::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::marshal(x0); + int x1_ = Marshaling::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::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::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::marshal(x0); + int x1_ = Marshaling::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::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 >*>::marshal(x0); + int x1_ = Marshaling::marshal(x1); + int x2_ = Marshaling::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 >*>::marshal(x0); + int x1_ = Marshaling::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::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::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::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::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 >*>::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::marshal(x0); + int x1_ = Marshaling::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::marshal(x0); + int x1_ = Marshaling::marshal(x1); + double x2_ = Marshaling::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 * x2, std::vector * x3, std::vector * 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 * x2, std::vector * x3, std::vector * 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 * x2, std::vector * x3, std::vector * x4); +CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC(int x0, int x1, std::vector * x2, std::vector * x3, std::vector * x4){ + int x0_ = Marshaling::marshal(x0); + int x1_ = Marshaling::marshal(x1); + std::vector x2_ = Marshaling,std::vector *>::marshal(x2); + std::vector x3_ = Marshaling,std::vector *>::marshal(x3); + std::vector x4_ = Marshaling,std::vector *>::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 * x2, std::vector * 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 * x2, std::vector * 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 * x2, std::vector * x3); +CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC(int x0, int x1, std::vector * x2, std::vector * x3){ + int x0_ = Marshaling::marshal(x0); + int x1_ = Marshaling::marshal(x1); + std::vector x2_ = Marshaling,std::vector *>::marshal(x2); + std::vector x3_ = Marshaling,std::vector *>::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 > * 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 > * x0)" +// call: "CasADi::Matrix< double >(x0_)" +extern "C" + CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC(std::vector > * x0); +CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC(std::vector > * x0){ + std::vector > x0_ = Marshaling >,std::vector > *>::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::marshal(x0); + double x1_ = Marshaling::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::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 * 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 * 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 * x1); +CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::CRSSparsity* x0, std::vector * x1){ + CasADi::CRSSparsity x0_ = Marshaling::marshal(x0); + std::vector x1_ = Marshaling,std::vector *>::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::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 * 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 * 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 * x0); +CasADi::Matrix< double >* CasADi__Matrix_double___DMatrix_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector * x0){ + std::vector x0_ = Marshaling,std::vector *>::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 * 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 * 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 * 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 * x0, int x1, int x2){ + std::vector x0_ = Marshaling,std::vector *>::marshal(x0); + int x1_ = Marshaling::marshal(x1); + int x2_ = Marshaling::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* obj); +void delete_std__vector_CasADi__MX_(std::vector* obj){ + delete obj; +} +extern "C" + void delete_std__vector_std__vector_CasADi__MX__(std::vector >* obj); +void delete_std__vector_std__vector_CasADi__MX__(std::vector >* obj){ + delete obj; +} +extern "C" + void delete_std__vector_std__vector_std__vector_CasADi__MX___(std::vector > >* obj); +void delete_std__vector_std__vector_std__vector_CasADi__MX___(std::vector > >* 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 * x0, std::vector * x1)" +// args: "(x0_, x1_)" +// rettype: Val (NonVec CVoid) +// cWrapperRetType: "void" +// proto: "void CasADi__MX__erase(CasADi::MX* obj, std::vector * x0, std::vector * x1)" +// call: "obj->erase(x0_, x1_)" +extern "C" + void CasADi__MX__erase(CasADi::MX* obj, std::vector * x0, std::vector * x1); +void CasADi__MX__erase(CasADi::MX* obj, std::vector * x0, std::vector * x1){ + std::vector x0_ = Marshaling,std::vector *>::marshal(x0); + std::vector x1_ = Marshaling,std::vector *>::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 * x2, std::vector * 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 * x2, std::vector * x3)" +// call: "obj->enlarge(x0_, x1_, x2_, x3_)" +extern "C" + void CasADi__MX__enlarge(CasADi::MX* obj, int x0, int x1, std::vector * x2, std::vector * x3); +void CasADi__MX__enlarge(CasADi::MX* obj, int x0, int x1, std::vector * x2, std::vector * x3){ + int x0_ = Marshaling::marshal(x0); + int x1_ = Marshaling::marshal(x1); + std::vector x2_ = Marshaling,std::vector *>::marshal(x2); + std::vector x3_ = Marshaling,std::vector *>::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::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::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::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::marshal(x0); + int x1_ = Marshaling::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::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::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::marshal(x0); + CasADi::MX x1_ = Marshaling::marshal(x1); + CasADi::MX x2_ = Marshaling::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::marshal(x0); + CasADi::MX x1_ = Marshaling::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::marshal(x0); + int x1_ = Marshaling::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::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::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::marshal(x0); + int x1_ = Marshaling::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::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::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::marshal(x0); + int x1_ = Marshaling::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::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::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::marshal(x0); + int x1_ = Marshaling::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::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::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::marshal(x0); + int x1_ = Marshaling::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::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::marshal(x0); + int x1_ = Marshaling::marshal(x1); + int x2_ = Marshaling::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::marshal(x0); + int x1_ = Marshaling::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::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::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 * x0)" +// args: "(x0_)" +// rettype: Val (NonVec (CasadiClass MX)) +// cWrapperRetType: "CasADi::MX*" +// proto: "CasADi::MX* CasADi__MX__getNZ_TIC(CasADi::MX* obj, std::vector * x0)" +// call: "obj->getNZ(x0_)" +extern "C" + CasADi::MX* CasADi__MX__getNZ_TIC(CasADi::MX* obj, std::vector * x0); +CasADi::MX* CasADi__MX__getNZ_TIC(CasADi::MX* obj, std::vector * x0){ + std::vector x0_ = Marshaling,std::vector *>::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::marshal(x0); + CasADi::CRSSparsity x1_ = Marshaling::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::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::marshal(x0); + CasADi::CRSSparsity x1_ = Marshaling::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::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::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::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::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::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::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::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::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::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::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::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::marshal(x0); + std::string x1_ = Marshaling::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::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::marshal(x0); + bool x1_ = Marshaling::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::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::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::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::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::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::marshal(x0); + int x1_ = Marshaling::marshal(x1); + int x2_ = Marshaling::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::marshal(x0); + int x1_ = Marshaling::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::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::marshal(x0); + CasADi::CRSSparsity x1_ = Marshaling::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::marshal(x0); + CasADi::MX x1_ = Marshaling::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::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::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::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 * 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 * x0)" +// call: "CasADi::MX(x0_)" +extern "C" + CasADi::MX* CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector * x0); +CasADi::MX* CasADi__MX__MX_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector * x0){ + std::vector x0_ = Marshaling,std::vector *>::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 >*>::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::marshal(x0); + int x1_ = Marshaling::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::marshal(x0); + int x1_ = Marshaling::marshal(x1); + CasADi::MX x2_ = Marshaling::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* obj); +void delete_std__vector_CasADi__CasadiOptions_(std::vector* obj){ + delete obj; +} +extern "C" + void delete_std__vector_std__vector_CasADi__CasadiOptions__(std::vector >* obj); +void delete_std__vector_std__vector_CasADi__CasadiOptions__(std::vector >* obj){ + delete obj; +} +extern "C" + void delete_std__vector_std__vector_std__vector_CasADi__CasadiOptions___(std::vector > >* obj); +void delete_std__vector_std__vector_std__vector_CasADi__CasadiOptions___(std::vector > >* 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::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::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::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* obj); +void delete_std__vector_CasADi__Callback_(std::vector* obj){ + delete obj; +} +extern "C" + void delete_std__vector_std__vector_CasADi__Callback__(std::vector >* obj); +void delete_std__vector_std__vector_CasADi__Callback__(std::vector >* obj){ + delete obj; +} +extern "C" + void delete_std__vector_std__vector_std__vector_CasADi__Callback___(std::vector > >* obj); +void delete_std__vector_std__vector_std__vector_CasADi__Callback___(std::vector > >* 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* obj); +void delete_std__vector_CasADi__CustomEvaluate_(std::vector* obj){ + delete obj; +} +extern "C" + void delete_std__vector_std__vector_CasADi__CustomEvaluate__(std::vector >* obj); +void delete_std__vector_std__vector_CasADi__CustomEvaluate__(std::vector >* obj){ + delete obj; +} +extern "C" + void delete_std__vector_std__vector_std__vector_CasADi__CustomEvaluate___(std::vector > >* obj); +void delete_std__vector_std__vector_std__vector_CasADi__CustomEvaluate___(std::vector > >* 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* obj); +void delete_std__vector_CasADi__ExternalFunction_(std::vector* obj){ + delete obj; +} +extern "C" + void delete_std__vector_std__vector_CasADi__ExternalFunction__(std::vector >* obj); +void delete_std__vector_std__vector_CasADi__ExternalFunction__(std::vector >* obj){ + delete obj; +} +extern "C" + void delete_std__vector_std__vector_std__vector_CasADi__ExternalFunction___(std::vector > >* obj); +void delete_std__vector_std__vector_std__vector_CasADi__ExternalFunction___(std::vector > >* 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::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* obj); +void delete_std__vector_CasADi__CSparse_(std::vector* obj){ + delete obj; +} +extern "C" + void delete_std__vector_std__vector_CasADi__CSparse__(std::vector >* obj); +void delete_std__vector_std__vector_CasADi__CSparse__(std::vector >* obj){ + delete obj; +} +extern "C" + void delete_std__vector_std__vector_std__vector_CasADi__CSparse___(std::vector > >* obj); +void delete_std__vector_std__vector_std__vector_CasADi__CSparse___(std::vector > >* 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::marshal(x0); + int x1_ = Marshaling::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::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* obj); +void delete_std__vector_CasADi__SX_(std::vector* obj){ + delete obj; +} +extern "C" + void delete_std__vector_std__vector_CasADi__SX__(std::vector >* obj); +void delete_std__vector_std__vector_CasADi__SX__(std::vector >* obj){ + delete obj; +} +extern "C" + void delete_std__vector_std__vector_std__vector_CasADi__SX___(std::vector > >* obj); +void delete_std__vector_std__vector_std__vector_CasADi__SX___(std::vector > >* 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::marshal(x0); + CasADi::SX x1_ = Marshaling::marshal(x1); + CasADi::SX x2_ = Marshaling::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::marshal(x0); + CasADi::SX x1_ = Marshaling::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::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::marshal(x0); + int x1_ = Marshaling::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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 >*>::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 >*>::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 >*>::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 >*>::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::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::marshal(x0); + int x1_ = Marshaling::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::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::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::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::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::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* obj); +void delete_std__vector_CasADi__CasadiMeta_(std::vector* obj){ + delete obj; +} +extern "C" + void delete_std__vector_std__vector_CasADi__CasadiMeta__(std::vector >* obj); +void delete_std__vector_std__vector_CasADi__CasadiMeta__(std::vector >* obj){ + delete obj; +} +extern "C" + void delete_std__vector_std__vector_std__vector_CasADi__CasadiMeta___(std::vector > >* obj); +void delete_std__vector_std__vector_std__vector_CasADi__CasadiMeta___(std::vector > >* 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* obj); +void delete_std__vector_CasADi__Functor_(std::vector* obj){ + delete obj; +} +extern "C" + void delete_std__vector_std__vector_CasADi__Functor__(std::vector >* obj); +void delete_std__vector_std__vector_CasADi__Functor__(std::vector >* obj){ + delete obj; +} +extern "C" + void delete_std__vector_std__vector_std__vector_CasADi__Functor___(std::vector > >* obj); +void delete_std__vector_std__vector_std__vector_CasADi__Functor___(std::vector > >* 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* obj); +void delete_std__vector_CasADi__CustomFunction_(std::vector* obj){ + delete obj; +} +extern "C" + void delete_std__vector_std__vector_CasADi__CustomFunction__(std::vector >* obj); +void delete_std__vector_std__vector_CasADi__CustomFunction__(std::vector >* obj){ + delete obj; +} +extern "C" + void delete_std__vector_std__vector_std__vector_CasADi__CustomFunction___(std::vector > >* obj); +void delete_std__vector_std__vector_std__vector_CasADi__CustomFunction___(std::vector > >* 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 * x1, std::vector * 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 * x1, std::vector * x2)" +// call: "CasADi::CustomFunction(x0_, x1_, x2_)" +extern "C" + CasADi::CustomFunction* CasADi__CustomFunction__CustomFunction_TIC(CasADi::CustomEvaluate* x0, std::vector * x1, std::vector * x2); +CasADi::CustomFunction* CasADi__CustomFunction__CustomFunction_TIC(CasADi::CustomEvaluate* x0, std::vector * x1, std::vector * x2){ + CasADi::CustomEvaluate x0_ = Marshaling::marshal(x0); + std::vector x1_ = Marshaling,std::vector *>::marshal(x1); + std::vector x2_ = Marshaling,std::vector *>::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::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::marshal(x0); + int x1_ = Marshaling::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::marshal(x0); + int x1_ = Marshaling::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::marshal(x0); + int x1_ = Marshaling::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::marshal(x0); + std::string x1_ = Marshaling::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::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::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::marshal(x0); + + return new std::string( CasADi::getSchemeEntryNames(x0_) ); +} + + +// ================== function "CasADi::complement" =============== +// cppName: "CasADi::complement" +// cWrapperName: "CasADi__complement" +// protoArgs: "(std::vector * x0, int x1)" +// params: [ConstRef (Vec (NonVec CInt)),Val (NonVec CInt)] +// args: "(x0_, x1_)" +// cWrapperRetType: "std::vector*" +// proto: "std::vector* CasADi__complement(std::vector * x0, int x1)" +// call: "CasADi::complement(x0_, x1_)" +extern "C" + std::vector* CasADi__complement(std::vector * x0, int x1); +std::vector* CasADi__complement(std::vector * x0, int x1){ + std::vector x0_ = Marshaling,std::vector *>::marshal(x0); + int x1_ = Marshaling::marshal(x1); + + return new std::vector( CasADi::complement(x0_, x1_) ); +} + + +// ================== function "CasADi::lookupvector" =============== +// cppName: "CasADi::lookupvector" +// cWrapperName: "CasADi__lookupvector" +// protoArgs: "(std::vector * x0, int x1)" +// params: [ConstRef (Vec (NonVec CInt)),Val (NonVec CInt)] +// args: "(x0_, x1_)" +// cWrapperRetType: "std::vector*" +// proto: "std::vector* CasADi__lookupvector(std::vector * x0, int x1)" +// call: "CasADi::lookupvector(x0_, x1_)" +extern "C" + std::vector* CasADi__lookupvector(std::vector * x0, int x1); +std::vector* CasADi__lookupvector(std::vector * x0, int x1){ + std::vector x0_ = Marshaling,std::vector *>::marshal(x0); + int x1_ = Marshaling::marshal(x1); + + return new std::vector( CasADi::lookupvector(x0_, x1_) ); +} + + +// ================== function "CasADi::isIncreasing" =============== +// cppName: "CasADi::isIncreasing" +// cWrapperName: "CasADi__isIncreasing" +// protoArgs: "(std::vector * x0)" +// params: [ConstRef (Vec (NonVec CInt))] +// args: "(x0_)" +// cWrapperRetType: "bool*" +// proto: "bool* CasADi__isIncreasing(std::vector * x0)" +// call: "CasADi::isIncreasing(x0_)" +extern "C" + bool* CasADi__isIncreasing(std::vector * x0); +bool* CasADi__isIncreasing(std::vector * x0){ + std::vector x0_ = Marshaling,std::vector *>::marshal(x0); + + return new bool( CasADi::isIncreasing(x0_) ); +} + + +// ================== function "CasADi::isDecreasing" =============== +// cppName: "CasADi::isDecreasing" +// cWrapperName: "CasADi__isDecreasing" +// protoArgs: "(std::vector * x0)" +// params: [ConstRef (Vec (NonVec CInt))] +// args: "(x0_)" +// cWrapperRetType: "bool*" +// proto: "bool* CasADi__isDecreasing(std::vector * x0)" +// call: "CasADi::isDecreasing(x0_)" +extern "C" + bool* CasADi__isDecreasing(std::vector * x0); +bool* CasADi__isDecreasing(std::vector * x0){ + std::vector x0_ = Marshaling,std::vector *>::marshal(x0); + + return new bool( CasADi::isDecreasing(x0_) ); +} + + +// ================== function "CasADi::isNonIncreasing" =============== +// cppName: "CasADi::isNonIncreasing" +// cWrapperName: "CasADi__isNonIncreasing" +// protoArgs: "(std::vector * x0)" +// params: [ConstRef (Vec (NonVec CInt))] +// args: "(x0_)" +// cWrapperRetType: "bool*" +// proto: "bool* CasADi__isNonIncreasing(std::vector * x0)" +// call: "CasADi::isNonIncreasing(x0_)" +extern "C" + bool* CasADi__isNonIncreasing(std::vector * x0); +bool* CasADi__isNonIncreasing(std::vector * x0){ + std::vector x0_ = Marshaling,std::vector *>::marshal(x0); + + return new bool( CasADi::isNonIncreasing(x0_) ); +} + + +// ================== function "CasADi::isNonDecreasing" =============== +// cppName: "CasADi::isNonDecreasing" +// cWrapperName: "CasADi__isNonDecreasing" +// protoArgs: "(std::vector * x0)" +// params: [ConstRef (Vec (NonVec CInt))] +// args: "(x0_)" +// cWrapperRetType: "bool*" +// proto: "bool* CasADi__isNonDecreasing(std::vector * x0)" +// call: "CasADi::isNonDecreasing(x0_)" +extern "C" + bool* CasADi__isNonDecreasing(std::vector * x0); +bool* CasADi__isNonDecreasing(std::vector * x0){ + std::vector x0_ = Marshaling,std::vector *>::marshal(x0); + + return new bool( CasADi::isNonDecreasing(x0_) ); +} + + +// ================== function "CasADi::isMonotone" =============== +// cppName: "CasADi::isMonotone" +// cWrapperName: "CasADi__isMonotone" +// protoArgs: "(std::vector * x0)" +// params: [ConstRef (Vec (NonVec CInt))] +// args: "(x0_)" +// cWrapperRetType: "bool*" +// proto: "bool* CasADi__isMonotone(std::vector * x0)" +// call: "CasADi::isMonotone(x0_)" +extern "C" + bool* CasADi__isMonotone(std::vector * x0); +bool* CasADi__isMonotone(std::vector * x0){ + std::vector x0_ = Marshaling,std::vector *>::marshal(x0); + + return new bool( CasADi::isMonotone(x0_) ); +} + + +// ================== function "CasADi::isStrictlyMonotone" =============== +// cppName: "CasADi::isStrictlyMonotone" +// cWrapperName: "CasADi__isStrictlyMonotone" +// protoArgs: "(std::vector * x0)" +// params: [ConstRef (Vec (NonVec CInt))] +// args: "(x0_)" +// cWrapperRetType: "bool*" +// proto: "bool* CasADi__isStrictlyMonotone(std::vector * x0)" +// call: "CasADi::isStrictlyMonotone(x0_)" +extern "C" + bool* CasADi__isStrictlyMonotone(std::vector * x0); +bool* CasADi__isStrictlyMonotone(std::vector * x0){ + std::vector x0_ = Marshaling,std::vector *>::marshal(x0); + + return new bool( CasADi::isStrictlyMonotone(x0_) ); +} + + +// ================== function "CasADi::isRegular" =============== +// cppName: "CasADi::isRegular" +// cWrapperName: "CasADi__isRegular" +// protoArgs: "(std::vector * x0)" +// params: [ConstRef (Vec (NonVec CInt))] +// args: "(x0_)" +// cWrapperRetType: "bool*" +// proto: "bool* CasADi__isRegular(std::vector * x0)" +// call: "CasADi::isRegular(x0_)" +extern "C" + bool* CasADi__isRegular(std::vector * x0); +bool* CasADi__isRegular(std::vector * x0){ + std::vector x0_ = Marshaling,std::vector *>::marshal(x0); + + return new bool( CasADi::isRegular(x0_) ); +} + + +// ================== function "CasADi::isIncreasing'" =============== +// cppName: "CasADi::isIncreasing'" +// cWrapperName: "CasADi__isIncreasing_TIC" +// protoArgs: "(std::vector * x0)" +// params: [ConstRef (Vec (NonVec CDouble))] +// args: "(x0_)" +// cWrapperRetType: "bool*" +// proto: "bool* CasADi__isIncreasing_TIC(std::vector * x0)" +// call: "CasADi::isIncreasing(x0_)" +extern "C" + bool* CasADi__isIncreasing_TIC(std::vector * x0); +bool* CasADi__isIncreasing_TIC(std::vector * x0){ + std::vector x0_ = Marshaling,std::vector *>::marshal(x0); + + return new bool( CasADi::isIncreasing(x0_) ); +} + + +// ================== function "CasADi::isDecreasing'" =============== +// cppName: "CasADi::isDecreasing'" +// cWrapperName: "CasADi__isDecreasing_TIC" +// protoArgs: "(std::vector * x0)" +// params: [ConstRef (Vec (NonVec CDouble))] +// args: "(x0_)" +// cWrapperRetType: "bool*" +// proto: "bool* CasADi__isDecreasing_TIC(std::vector * x0)" +// call: "CasADi::isDecreasing(x0_)" +extern "C" + bool* CasADi__isDecreasing_TIC(std::vector * x0); +bool* CasADi__isDecreasing_TIC(std::vector * x0){ + std::vector x0_ = Marshaling,std::vector *>::marshal(x0); + + return new bool( CasADi::isDecreasing(x0_) ); +} + + +// ================== function "CasADi::isNonIncreasing'" =============== +// cppName: "CasADi::isNonIncreasing'" +// cWrapperName: "CasADi__isNonIncreasing_TIC" +// protoArgs: "(std::vector * x0)" +// params: [ConstRef (Vec (NonVec CDouble))] +// args: "(x0_)" +// cWrapperRetType: "bool*" +// proto: "bool* CasADi__isNonIncreasing_TIC(std::vector * x0)" +// call: "CasADi::isNonIncreasing(x0_)" +extern "C" + bool* CasADi__isNonIncreasing_TIC(std::vector * x0); +bool* CasADi__isNonIncreasing_TIC(std::vector * x0){ + std::vector x0_ = Marshaling,std::vector *>::marshal(x0); + + return new bool( CasADi::isNonIncreasing(x0_) ); +} + + +// ================== function "CasADi::isNonDecreasing'" =============== +// cppName: "CasADi::isNonDecreasing'" +// cWrapperName: "CasADi__isNonDecreasing_TIC" +// protoArgs: "(std::vector * x0)" +// params: [ConstRef (Vec (NonVec CDouble))] +// args: "(x0_)" +// cWrapperRetType: "bool*" +// proto: "bool* CasADi__isNonDecreasing_TIC(std::vector * x0)" +// call: "CasADi::isNonDecreasing(x0_)" +extern "C" + bool* CasADi__isNonDecreasing_TIC(std::vector * x0); +bool* CasADi__isNonDecreasing_TIC(std::vector * x0){ + std::vector x0_ = Marshaling,std::vector *>::marshal(x0); + + return new bool( CasADi::isNonDecreasing(x0_) ); +} + + +// ================== function "CasADi::isMonotone'" =============== +// cppName: "CasADi::isMonotone'" +// cWrapperName: "CasADi__isMonotone_TIC" +// protoArgs: "(std::vector * x0)" +// params: [ConstRef (Vec (NonVec CDouble))] +// args: "(x0_)" +// cWrapperRetType: "bool*" +// proto: "bool* CasADi__isMonotone_TIC(std::vector * x0)" +// call: "CasADi::isMonotone(x0_)" +extern "C" + bool* CasADi__isMonotone_TIC(std::vector * x0); +bool* CasADi__isMonotone_TIC(std::vector * x0){ + std::vector x0_ = Marshaling,std::vector *>::marshal(x0); + + return new bool( CasADi::isMonotone(x0_) ); +} + + +// ================== function "CasADi::isStrictlyMonotone'" =============== +// cppName: "CasADi::isStrictlyMonotone'" +// cWrapperName: "CasADi__isStrictlyMonotone_TIC" +// protoArgs: "(std::vector * x0)" +// params: [ConstRef (Vec (NonVec CDouble))] +// args: "(x0_)" +// cWrapperRetType: "bool*" +// proto: "bool* CasADi__isStrictlyMonotone_TIC(std::vector * x0)" +// call: "CasADi::isStrictlyMonotone(x0_)" +extern "C" + bool* CasADi__isStrictlyMonotone_TIC(std::vector * x0); +bool* CasADi__isStrictlyMonotone_TIC(std::vector * x0){ + std::vector x0_ = Marshaling,std::vector *>::marshal(x0); + + return new bool( CasADi::isStrictlyMonotone(x0_) ); +} + + +// ================== function "CasADi::isRegular'" =============== +// cppName: "CasADi::isRegular'" +// cWrapperName: "CasADi__isRegular_TIC" +// protoArgs: "(std::vector * x0)" +// params: [ConstRef (Vec (NonVec CDouble))] +// args: "(x0_)" +// cWrapperRetType: "bool*" +// proto: "bool* CasADi__isRegular_TIC(std::vector * x0)" +// call: "CasADi::isRegular(x0_)" +extern "C" + bool* CasADi__isRegular_TIC(std::vector * x0); +bool* CasADi__isRegular_TIC(std::vector * x0){ + std::vector x0_ = Marshaling,std::vector *>::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 >*>::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 >*>::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 >*>::marshal(x0); + CasADi::Matrix< double > x1_ = Marshaling,CasADi::Matrix< double >*>::marshal(x1); + CasADi::CRSSparsity x2_ = Marshaling::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 >*>::marshal(x0); + CasADi::Matrix< double > x1_ = Marshaling,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* > * 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* > * x0)" +// call: "CasADi::mul(x0_)" +extern "C" + CasADi::Matrix< double >* CasADi__mul_TIC_TIC_TIC_TIC_TIC(std::vector* > * x0); +CasADi::Matrix< double >* CasADi__mul_TIC_TIC_TIC_TIC_TIC(std::vector* > * x0){ + std::vector > x0_ = Marshaling >,std::vector* > *>::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 >*>::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 >*>::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 >*>::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 >*>::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 >*>::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 >*>::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 >*>::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 >*>::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 >*>::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 >*>::marshal(x0); + int x1_ = Marshaling::marshal(x1); + int x2_ = Marshaling::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 >*>::marshal(x0); + int x1_ = Marshaling::marshal(x1); + int x2_ = Marshaling::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 >*>::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 >*>::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 >*>::marshal(x0); + int x1_ = Marshaling::marshal(x1); + int x2_ = Marshaling::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 >*>::marshal(x0); + CasADi::CRSSparsity x1_ = Marshaling::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 >*>::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 >*>::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 >*>::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 >*>::marshal(x0); + + return new CasADi::Matrix< double >( CasADi::flattenNZ(x0_) ); +} + + +// ================== function "CasADi::blockcat'" =============== +// cppName: "CasADi::blockcat'" +// cWrapperName: "CasADi__blockcat_TIC" +// protoArgs: "(std::vector* > > * x0)" +// params: [ConstRef (Vec (Vec (NonVec (CasadiClass DMatrix))))] +// args: "(x0_)" +// cWrapperRetType: "CasADi::Matrix< double >*" +// proto: "CasADi::Matrix< double >* CasADi__blockcat_TIC(std::vector* > > * x0)" +// call: "CasADi::blockcat(x0_)" +extern "C" + CasADi::Matrix< double >* CasADi__blockcat_TIC(std::vector* > > * x0); +CasADi::Matrix< double >* CasADi__blockcat_TIC(std::vector* > > * x0){ + std::vector > > x0_ = Marshaling > >,std::vector* > > *>::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 * x1, std::vector * x2)" +// params: [ConstRef (NonVec (CasadiClass DMatrix)),ConstRef (Vec (NonVec CInt)),ConstRef (Vec (NonVec CInt))] +// args: "(x0_, x1_, x2_)" +// cWrapperRetType: "std::vector > >*" +// proto: "std::vector > >* CasADi__blocksplit_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* x0, std::vector * x1, std::vector * x2)" +// call: "CasADi::blocksplit(x0_, x1_, x2_)" +extern "C" + std::vector > >* CasADi__blocksplit_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* x0, std::vector * x1, std::vector * x2); +std::vector > >* CasADi__blocksplit_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* x0, std::vector * x1, std::vector * x2){ + CasADi::Matrix< double > x0_ = Marshaling,CasADi::Matrix< double >*>::marshal(x0); + std::vector x1_ = Marshaling,std::vector *>::marshal(x1); + std::vector x2_ = Marshaling,std::vector *>::marshal(x2); + + return new std::vector > >( 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 > >*" +// proto: "std::vector > >* 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 > >* CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* x0, int x1, int x2); +std::vector > >* CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* x0, int x1, int x2){ + CasADi::Matrix< double > x0_ = Marshaling,CasADi::Matrix< double >*>::marshal(x0); + int x1_ = Marshaling::marshal(x1); + int x2_ = Marshaling::marshal(x2); + + return new std::vector > >( 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 > >*" +// proto: "std::vector > >* CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* x0, int x1)" +// call: "CasADi::blocksplit(x0_, x1_)" +extern "C" + std::vector > >* CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* x0, int x1); +std::vector > >* CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* x0, int x1){ + CasADi::Matrix< double > x0_ = Marshaling,CasADi::Matrix< double >*>::marshal(x0); + int x1_ = Marshaling::marshal(x1); + + return new std::vector > >( 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 > >*" +// proto: "std::vector > >* CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* x0)" +// call: "CasADi::blocksplit(x0_)" +extern "C" + std::vector > >* CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* x0); +std::vector > >* CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* x0){ + CasADi::Matrix< double > x0_ = Marshaling,CasADi::Matrix< double >*>::marshal(x0); + + return new std::vector > >( CasADi::blocksplit(x0_) ); +} + + +// ================== function "CasADi::horzcat'" =============== +// cppName: "CasADi::horzcat'" +// cWrapperName: "CasADi__horzcat_TIC" +// protoArgs: "(std::vector* > * x0)" +// params: [ConstRef (Vec (NonVec (CasadiClass DMatrix)))] +// args: "(x0_)" +// cWrapperRetType: "CasADi::Matrix< double >*" +// proto: "CasADi::Matrix< double >* CasADi__horzcat_TIC(std::vector* > * x0)" +// call: "CasADi::horzcat(x0_)" +extern "C" + CasADi::Matrix< double >* CasADi__horzcat_TIC(std::vector* > * x0); +CasADi::Matrix< double >* CasADi__horzcat_TIC(std::vector* > * x0){ + std::vector > x0_ = Marshaling >,std::vector* > *>::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 * x1)" +// params: [ConstRef (NonVec (CasadiClass DMatrix)),ConstRef (Vec (NonVec CInt))] +// args: "(x0_, x1_)" +// cWrapperRetType: "std::vector >*" +// proto: "std::vector >* CasADi__horzsplit_TIC_TIC_TIC(CasADi::Matrix< double >* x0, std::vector * x1)" +// call: "CasADi::horzsplit(x0_, x1_)" +extern "C" + std::vector >* CasADi__horzsplit_TIC_TIC_TIC(CasADi::Matrix< double >* x0, std::vector * x1); +std::vector >* CasADi__horzsplit_TIC_TIC_TIC(CasADi::Matrix< double >* x0, std::vector * x1){ + CasADi::Matrix< double > x0_ = Marshaling,CasADi::Matrix< double >*>::marshal(x0); + std::vector x1_ = Marshaling,std::vector *>::marshal(x1); + + return new std::vector >( 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 >*" +// proto: "std::vector >* CasADi__horzsplit_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* x0, int x1)" +// call: "CasADi::horzsplit(x0_, x1_)" +extern "C" + std::vector >* CasADi__horzsplit_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* x0, int x1); +std::vector >* CasADi__horzsplit_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* x0, int x1){ + CasADi::Matrix< double > x0_ = Marshaling,CasADi::Matrix< double >*>::marshal(x0); + int x1_ = Marshaling::marshal(x1); + + return new std::vector >( 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 >*" +// proto: "std::vector >* CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* x0)" +// call: "CasADi::horzsplit(x0_)" +extern "C" + std::vector >* CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* x0); +std::vector >* CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* x0){ + CasADi::Matrix< double > x0_ = Marshaling,CasADi::Matrix< double >*>::marshal(x0); + + return new std::vector >( CasADi::horzsplit(x0_) ); +} + + +// ================== function "CasADi::vertcat'" =============== +// cppName: "CasADi::vertcat'" +// cWrapperName: "CasADi__vertcat_TIC" +// protoArgs: "(std::vector* > * x0)" +// params: [ConstRef (Vec (NonVec (CasadiClass DMatrix)))] +// args: "(x0_)" +// cWrapperRetType: "CasADi::Matrix< double >*" +// proto: "CasADi::Matrix< double >* CasADi__vertcat_TIC(std::vector* > * x0)" +// call: "CasADi::vertcat(x0_)" +extern "C" + CasADi::Matrix< double >* CasADi__vertcat_TIC(std::vector* > * x0); +CasADi::Matrix< double >* CasADi__vertcat_TIC(std::vector* > * x0){ + std::vector > x0_ = Marshaling >,std::vector* > *>::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 * x1)" +// params: [ConstRef (NonVec (CasadiClass DMatrix)),ConstRef (Vec (NonVec CInt))] +// args: "(x0_, x1_)" +// cWrapperRetType: "std::vector >*" +// proto: "std::vector >* CasADi__vertsplit_TIC_TIC_TIC(CasADi::Matrix< double >* x0, std::vector * x1)" +// call: "CasADi::vertsplit(x0_, x1_)" +extern "C" + std::vector >* CasADi__vertsplit_TIC_TIC_TIC(CasADi::Matrix< double >* x0, std::vector * x1); +std::vector >* CasADi__vertsplit_TIC_TIC_TIC(CasADi::Matrix< double >* x0, std::vector * x1){ + CasADi::Matrix< double > x0_ = Marshaling,CasADi::Matrix< double >*>::marshal(x0); + std::vector x1_ = Marshaling,std::vector *>::marshal(x1); + + return new std::vector >( 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 >*" +// proto: "std::vector >* CasADi__vertsplit_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* x0, int x1)" +// call: "CasADi::vertsplit(x0_, x1_)" +extern "C" + std::vector >* CasADi__vertsplit_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* x0, int x1); +std::vector >* CasADi__vertsplit_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* x0, int x1){ + CasADi::Matrix< double > x0_ = Marshaling,CasADi::Matrix< double >*>::marshal(x0); + int x1_ = Marshaling::marshal(x1); + + return new std::vector >( 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 >*" +// proto: "std::vector >* CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* x0)" +// call: "CasADi::vertsplit(x0_)" +extern "C" + std::vector >* CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* x0); +std::vector >* CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< double >* x0){ + CasADi::Matrix< double > x0_ = Marshaling,CasADi::Matrix< double >*>::marshal(x0); + + return new std::vector >( 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 >*>::marshal(x0); + CasADi::Matrix< double > x1_ = Marshaling,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 >*>::marshal(x0); + CasADi::Matrix< double > x1_ = Marshaling,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 >*>::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 >*>::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 >*>::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 >*>::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 >*>::marshal(x0); + CasADi::Matrix< double > x1_ = Marshaling,CasADi::Matrix< double >*>::marshal(x1); + CasADi::Matrix< double > x2_ = Marshaling,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 >*>::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 >*>::marshal(x0); + CasADi::Matrix< double > x1_ = Marshaling,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 >*>::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 >*>::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 >*>::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 >*>::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 >*>::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 >*>::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 >*>::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 >*>::marshal(x0); + CasADi::Matrix< double > x1_ = Marshaling,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 >*>::marshal(x0); + int x1_ = Marshaling::marshal(x1); + int x2_ = Marshaling::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 >*" +// proto: "std::vector >* CasADi__getSparseTriplet_TIC(CasADi::Matrix< double >* x0)" +// call: "CasADi::getSparseTriplet(x0_)" +extern "C" + std::vector >* CasADi__getSparseTriplet_TIC(CasADi::Matrix< double >* x0); +std::vector >* CasADi__getSparseTriplet_TIC(CasADi::Matrix< double >* x0){ + CasADi::Matrix< double > x0_ = Marshaling,CasADi::Matrix< double >*>::marshal(x0); + + return new std::vector >( 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 >*>::marshal(x0); + CasADi::Matrix< double > x1_ = Marshaling,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 >*>::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 >*>::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 >*>::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 >*>::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 >*>::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 >*>::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 >*>::marshal(x0); + double x1_ = Marshaling::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 >*>::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 >*>::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 >*>::marshal(x0); + + return new CasADi::Matrix< double >( CasADi::diag(x0_) ); +} + + +// ================== function "CasADi::blkdiag'" =============== +// cppName: "CasADi::blkdiag'" +// cWrapperName: "CasADi__blkdiag_TIC" +// protoArgs: "(std::vector* > * x0)" +// params: [ConstRef (Vec (NonVec (CasadiClass DMatrix)))] +// args: "(x0_)" +// cWrapperRetType: "CasADi::Matrix< double >*" +// proto: "CasADi::Matrix< double >* CasADi__blkdiag_TIC(std::vector* > * x0)" +// call: "CasADi::blkdiag(x0_)" +extern "C" + CasADi::Matrix< double >* CasADi__blkdiag_TIC(std::vector* > * x0); +CasADi::Matrix< double >* CasADi__blkdiag_TIC(std::vector* > * x0){ + std::vector > x0_ = Marshaling >,std::vector* > *>::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 >*>::marshal(x0); + CasADi::Matrix< double > x1_ = Marshaling,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 * x1, std::vector* 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 * x1, std::vector* x2, bool* x3)" +// call: "CasADi::addMultiple(x0_, x1_, x2_, x3_)" +extern "C" + void CasADi__addMultiple_TIC_TIC(CasADi::Matrix< double >* x0, std::vector * x1, std::vector* x2, bool* x3); +void CasADi__addMultiple_TIC_TIC(CasADi::Matrix< double >* x0, std::vector * x1, std::vector* x2, bool* x3){ + CasADi::Matrix< double > x0_ = Marshaling,CasADi::Matrix< double >*>::marshal(x0); + std::vector x1_ = Marshaling,std::vector *>::marshal(x1); + std::vector x2_ = Marshaling,std::vector*>::marshal(x2); + bool x3_ = Marshaling::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 * x1, std::vector* 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 * x1, std::vector* x2)" +// call: "CasADi::addMultiple(x0_, x1_, x2_)" +extern "C" + void CasADi__addMultiple_TIC_TIC_TIC(CasADi::Matrix< double >* x0, std::vector * x1, std::vector* x2); +void CasADi__addMultiple_TIC_TIC_TIC(CasADi::Matrix< double >* x0, std::vector * x1, std::vector* x2){ + CasADi::Matrix< double > x0_ = Marshaling,CasADi::Matrix< double >*>::marshal(x0); + std::vector x1_ = Marshaling,std::vector *>::marshal(x1); + std::vector x2_ = Marshaling,std::vector*>::marshal(x2); + + return CasADi::addMultiple(x0_, x1_, x2_); +} + + +// ================== function "CasADi::veccat'" =============== +// cppName: "CasADi::veccat'" +// cWrapperName: "CasADi__veccat_TIC" +// protoArgs: "(std::vector* > * x0)" +// params: [ConstRef (Vec (NonVec (CasadiClass DMatrix)))] +// args: "(x0_)" +// cWrapperRetType: "CasADi::Matrix< double >*" +// proto: "CasADi::Matrix< double >* CasADi__veccat_TIC(std::vector* > * x0)" +// call: "CasADi::veccat(x0_)" +extern "C" + CasADi::Matrix< double >* CasADi__veccat_TIC(std::vector* > * x0); +CasADi::Matrix< double >* CasADi__veccat_TIC(std::vector* > * x0){ + std::vector > x0_ = Marshaling >,std::vector* > *>::marshal(x0); + + return new CasADi::Matrix< double >( CasADi::veccat(x0_) ); +} + + +// ================== function "CasADi::vecNZcat'" =============== +// cppName: "CasADi::vecNZcat'" +// cWrapperName: "CasADi__vecNZcat_TIC" +// protoArgs: "(std::vector* > * x0)" +// params: [ConstRef (Vec (NonVec (CasadiClass DMatrix)))] +// args: "(x0_)" +// cWrapperRetType: "CasADi::Matrix< double >*" +// proto: "CasADi::Matrix< double >* CasADi__vecNZcat_TIC(std::vector* > * x0)" +// call: "CasADi::vecNZcat(x0_)" +extern "C" + CasADi::Matrix< double >* CasADi__vecNZcat_TIC(std::vector* > * x0); +CasADi::Matrix< double >* CasADi__vecNZcat_TIC(std::vector* > * x0){ + std::vector > x0_ = Marshaling >,std::vector* > *>::marshal(x0); + + return new CasADi::Matrix< double >( CasADi::vecNZcat(x0_) ); +} + + +// ================== function "CasADi::flattencat'" =============== +// cppName: "CasADi::flattencat'" +// cWrapperName: "CasADi__flattencat_TIC" +// protoArgs: "(std::vector* > * x0)" +// params: [ConstRef (Vec (NonVec (CasadiClass DMatrix)))] +// args: "(x0_)" +// cWrapperRetType: "CasADi::Matrix< double >*" +// proto: "CasADi::Matrix< double >* CasADi__flattencat_TIC(std::vector* > * x0)" +// call: "CasADi::flattencat(x0_)" +extern "C" + CasADi::Matrix< double >* CasADi__flattencat_TIC(std::vector* > * x0); +CasADi::Matrix< double >* CasADi__flattencat_TIC(std::vector* > * x0){ + std::vector > x0_ = Marshaling >,std::vector* > *>::marshal(x0); + + return new CasADi::Matrix< double >( CasADi::flattencat(x0_) ); +} + + +// ================== function "CasADi::flattenNZcat'" =============== +// cppName: "CasADi::flattenNZcat'" +// cWrapperName: "CasADi__flattenNZcat_TIC" +// protoArgs: "(std::vector* > * x0)" +// params: [ConstRef (Vec (NonVec (CasadiClass DMatrix)))] +// args: "(x0_)" +// cWrapperRetType: "CasADi::Matrix< double >*" +// proto: "CasADi::Matrix< double >* CasADi__flattenNZcat_TIC(std::vector* > * x0)" +// call: "CasADi::flattenNZcat(x0_)" +extern "C" + CasADi::Matrix< double >* CasADi__flattenNZcat_TIC(std::vector* > * x0); +CasADi::Matrix< double >* CasADi__flattenNZcat_TIC(std::vector* > * x0){ + std::vector > x0_ = Marshaling >,std::vector* > *>::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 >*>::marshal(x0); + CasADi::CRSSparsity x1_ = Marshaling::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 >*>::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 >*>::marshal(x0); + CasADi::Matrix< double > x1_ = Marshaling,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 >*>::marshal(x0); + double x1_ = Marshaling::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 >*>::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 >*>::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 >*>::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 >*>::marshal(x0); + CasADi::Matrix< CasADi::SX > x1_ = Marshaling,CasADi::Matrix< CasADi::SX >*>::marshal(x1); + CasADi::CRSSparsity x2_ = Marshaling::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 >*>::marshal(x0); + CasADi::Matrix< CasADi::SX > x1_ = Marshaling,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* > * 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* > * x0)" +// call: "CasADi::mul(x0_)" +extern "C" + CasADi::Matrix< CasADi::SX >* CasADi__mul_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector* > * x0); +CasADi::Matrix< CasADi::SX >* CasADi__mul_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector* > * x0){ + std::vector > x0_ = Marshaling >,std::vector* > *>::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 >*>::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 >*>::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 >*>::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 >*>::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 >*>::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 >*>::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 >*>::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 >*>::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 >*>::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 >*>::marshal(x0); + int x1_ = Marshaling::marshal(x1); + int x2_ = Marshaling::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 >*>::marshal(x0); + int x1_ = Marshaling::marshal(x1); + int x2_ = Marshaling::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 >*>::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 >*>::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 >*>::marshal(x0); + int x1_ = Marshaling::marshal(x1); + int x2_ = Marshaling::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 >*>::marshal(x0); + CasADi::CRSSparsity x1_ = Marshaling::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 >*>::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 >*>::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 >*>::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 >*>::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* > > * 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* > > * x0)" +// call: "CasADi::blockcat(x0_)" +extern "C" + CasADi::Matrix< CasADi::SX >* CasADi__blockcat_TIC_TIC(std::vector* > > * x0); +CasADi::Matrix< CasADi::SX >* CasADi__blockcat_TIC_TIC(std::vector* > > * x0){ + std::vector > > x0_ = Marshaling > >,std::vector* > > *>::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 * x1, std::vector * x2)" +// params: [ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (Vec (NonVec CInt)),ConstRef (Vec (NonVec CInt))] +// args: "(x0_, x1_, x2_)" +// cWrapperRetType: "std::vector > >*" +// proto: "std::vector > >* CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, std::vector * x1, std::vector * x2)" +// call: "CasADi::blocksplit(x0_, x1_, x2_)" +extern "C" + std::vector > >* CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, std::vector * x1, std::vector * x2); +std::vector > >* CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, std::vector * x1, std::vector * x2){ + CasADi::Matrix< CasADi::SX > x0_ = Marshaling,CasADi::Matrix< CasADi::SX >*>::marshal(x0); + std::vector x1_ = Marshaling,std::vector *>::marshal(x1); + std::vector x2_ = Marshaling,std::vector *>::marshal(x2); + + return new std::vector > >( 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 > >*" +// proto: "std::vector > >* 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 > >* CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, int x1, int x2); +std::vector > >* 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 >*>::marshal(x0); + int x1_ = Marshaling::marshal(x1); + int x2_ = Marshaling::marshal(x2); + + return new std::vector > >( 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 > >*" +// proto: "std::vector > >* 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 > >* CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, int x1); +std::vector > >* 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 >*>::marshal(x0); + int x1_ = Marshaling::marshal(x1); + + return new std::vector > >( 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 > >*" +// proto: "std::vector > >* 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 > >* CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0); +std::vector > >* 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 >*>::marshal(x0); + + return new std::vector > >( CasADi::blocksplit(x0_) ); +} + + +// ================== function "CasADi::horzcat''" =============== +// cppName: "CasADi::horzcat''" +// cWrapperName: "CasADi__horzcat_TIC_TIC" +// protoArgs: "(std::vector* > * 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* > * x0)" +// call: "CasADi::horzcat(x0_)" +extern "C" + CasADi::Matrix< CasADi::SX >* CasADi__horzcat_TIC_TIC(std::vector* > * x0); +CasADi::Matrix< CasADi::SX >* CasADi__horzcat_TIC_TIC(std::vector* > * x0){ + std::vector > x0_ = Marshaling >,std::vector* > *>::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 * x1)" +// params: [ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (Vec (NonVec CInt))] +// args: "(x0_, x1_)" +// cWrapperRetType: "std::vector >*" +// proto: "std::vector >* CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, std::vector * x1)" +// call: "CasADi::horzsplit(x0_, x1_)" +extern "C" + std::vector >* CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, std::vector * x1); +std::vector >* CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, std::vector * x1){ + CasADi::Matrix< CasADi::SX > x0_ = Marshaling,CasADi::Matrix< CasADi::SX >*>::marshal(x0); + std::vector x1_ = Marshaling,std::vector *>::marshal(x1); + + return new std::vector >( 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 >*" +// proto: "std::vector >* 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__horzsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, int x1); +std::vector >* 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 >*>::marshal(x0); + int x1_ = Marshaling::marshal(x1); + + return new std::vector >( 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 >*" +// proto: "std::vector >* CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0)" +// call: "CasADi::horzsplit(x0_)" +extern "C" + std::vector >* CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0); +std::vector >* 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 >*>::marshal(x0); + + return new std::vector >( CasADi::horzsplit(x0_) ); +} + + +// ================== function "CasADi::vertcat''" =============== +// cppName: "CasADi::vertcat''" +// cWrapperName: "CasADi__vertcat_TIC_TIC" +// protoArgs: "(std::vector* > * 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* > * x0)" +// call: "CasADi::vertcat(x0_)" +extern "C" + CasADi::Matrix< CasADi::SX >* CasADi__vertcat_TIC_TIC(std::vector* > * x0); +CasADi::Matrix< CasADi::SX >* CasADi__vertcat_TIC_TIC(std::vector* > * x0){ + std::vector > x0_ = Marshaling >,std::vector* > *>::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 * x1)" +// params: [ConstRef (NonVec (CasadiClass SXMatrix)),ConstRef (Vec (NonVec CInt))] +// args: "(x0_, x1_)" +// cWrapperRetType: "std::vector >*" +// proto: "std::vector >* CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, std::vector * x1)" +// call: "CasADi::vertsplit(x0_, x1_)" +extern "C" + std::vector >* CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, std::vector * x1); +std::vector >* CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, std::vector * x1){ + CasADi::Matrix< CasADi::SX > x0_ = Marshaling,CasADi::Matrix< CasADi::SX >*>::marshal(x0); + std::vector x1_ = Marshaling,std::vector *>::marshal(x1); + + return new std::vector >( 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 >*" +// proto: "std::vector >* 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__vertsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, int x1); +std::vector >* 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 >*>::marshal(x0); + int x1_ = Marshaling::marshal(x1); + + return new std::vector >( 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 >*" +// proto: "std::vector >* CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0)" +// call: "CasADi::vertsplit(x0_)" +extern "C" + std::vector >* CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0); +std::vector >* 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 >*>::marshal(x0); + + return new std::vector >( 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 >*>::marshal(x0); + CasADi::Matrix< CasADi::SX > x1_ = Marshaling,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 >*>::marshal(x0); + CasADi::Matrix< CasADi::SX > x1_ = Marshaling,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 >*>::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 >*>::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 >*>::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 >*>::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 >*>::marshal(x0); + CasADi::Matrix< CasADi::SX > x1_ = Marshaling,CasADi::Matrix< CasADi::SX >*>::marshal(x1); + CasADi::Matrix< CasADi::SX > x2_ = Marshaling,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 >*>::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 >*>::marshal(x0); + CasADi::Matrix< CasADi::SX > x1_ = Marshaling,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 >*>::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 >*>::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 >*>::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 >*>::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 >*>::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 >*>::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 >*>::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 >*>::marshal(x0); + CasADi::Matrix< CasADi::SX > x1_ = Marshaling,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 >*>::marshal(x0); + int x1_ = Marshaling::marshal(x1); + int x2_ = Marshaling::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 >*" +// proto: "std::vector >* CasADi__getSparseTriplet_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0)" +// call: "CasADi::getSparseTriplet(x0_)" +extern "C" + std::vector >* CasADi__getSparseTriplet_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0); +std::vector >* CasADi__getSparseTriplet_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0){ + CasADi::Matrix< CasADi::SX > x0_ = Marshaling,CasADi::Matrix< CasADi::SX >*>::marshal(x0); + + return new std::vector >( 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 >*>::marshal(x0); + CasADi::Matrix< CasADi::SX > x1_ = Marshaling,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 >*>::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 >*>::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 >*>::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 >*>::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 >*>::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 >*>::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 >*>::marshal(x0); + double x1_ = Marshaling::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 >*>::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 >*>::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 >*>::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* > * 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* > * x0)" +// call: "CasADi::blkdiag(x0_)" +extern "C" + CasADi::Matrix< CasADi::SX >* CasADi__blkdiag_TIC_TIC(std::vector* > * x0); +CasADi::Matrix< CasADi::SX >* CasADi__blkdiag_TIC_TIC(std::vector* > * x0){ + std::vector > x0_ = Marshaling >,std::vector* > *>::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 >*>::marshal(x0); + CasADi::Matrix< CasADi::SX > x1_ = Marshaling,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 * x1, std::vector* 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 * x1, std::vector* 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 * x1, std::vector* x2, bool* x3); +void CasADi__addMultiple_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, std::vector * x1, std::vector* x2, bool* x3){ + CasADi::Matrix< CasADi::SX > x0_ = Marshaling,CasADi::Matrix< CasADi::SX >*>::marshal(x0); + std::vector x1_ = Marshaling,std::vector *>::marshal(x1); + std::vector x2_ = Marshaling,std::vector*>::marshal(x2); + bool x3_ = Marshaling::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 * x1, std::vector* 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 * x1, std::vector* x2)" +// call: "CasADi::addMultiple(x0_, x1_, x2_)" +extern "C" + void CasADi__addMultiple_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, std::vector * x1, std::vector* x2); +void CasADi__addMultiple_TIC_TIC_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, std::vector * x1, std::vector* x2){ + CasADi::Matrix< CasADi::SX > x0_ = Marshaling,CasADi::Matrix< CasADi::SX >*>::marshal(x0); + std::vector x1_ = Marshaling,std::vector *>::marshal(x1); + std::vector x2_ = Marshaling,std::vector*>::marshal(x2); + + return CasADi::addMultiple(x0_, x1_, x2_); +} + + +// ================== function "CasADi::veccat''" =============== +// cppName: "CasADi::veccat''" +// cWrapperName: "CasADi__veccat_TIC_TIC" +// protoArgs: "(std::vector* > * 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* > * x0)" +// call: "CasADi::veccat(x0_)" +extern "C" + CasADi::Matrix< CasADi::SX >* CasADi__veccat_TIC_TIC(std::vector* > * x0); +CasADi::Matrix< CasADi::SX >* CasADi__veccat_TIC_TIC(std::vector* > * x0){ + std::vector > x0_ = Marshaling >,std::vector* > *>::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* > * 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* > * x0)" +// call: "CasADi::vecNZcat(x0_)" +extern "C" + CasADi::Matrix< CasADi::SX >* CasADi__vecNZcat_TIC_TIC(std::vector* > * x0); +CasADi::Matrix< CasADi::SX >* CasADi__vecNZcat_TIC_TIC(std::vector* > * x0){ + std::vector > x0_ = Marshaling >,std::vector* > *>::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* > * 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* > * x0)" +// call: "CasADi::flattencat(x0_)" +extern "C" + CasADi::Matrix< CasADi::SX >* CasADi__flattencat_TIC_TIC(std::vector* > * x0); +CasADi::Matrix< CasADi::SX >* CasADi__flattencat_TIC_TIC(std::vector* > * x0){ + std::vector > x0_ = Marshaling >,std::vector* > *>::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* > * 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* > * x0)" +// call: "CasADi::flattenNZcat(x0_)" +extern "C" + CasADi::Matrix< CasADi::SX >* CasADi__flattenNZcat_TIC_TIC(std::vector* > * x0); +CasADi::Matrix< CasADi::SX >* CasADi__flattenNZcat_TIC_TIC(std::vector* > * x0){ + std::vector > x0_ = Marshaling >,std::vector* > *>::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 >*>::marshal(x0); + CasADi::CRSSparsity x1_ = Marshaling::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 >*>::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 >*>::marshal(x0); + CasADi::Matrix< CasADi::SX > x1_ = Marshaling,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 >*>::marshal(x0); + double x1_ = Marshaling::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 >*>::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 >*>::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::marshal(x0); + int x1_ = Marshaling::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::marshal(x0); + int x1_ = Marshaling::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::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::marshal(x0); + double x1_ = Marshaling::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::marshal(x0); + double x1_ = Marshaling::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::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 >*>::marshal(x0); + CasADi::Matrix< double > x1_ = Marshaling,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 >*>::marshal(x0); + CasADi::Matrix< double > x1_ = Marshaling,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 >*>::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 >*>::marshal(x0); + CasADi::Matrix< CasADi::SX > x1_ = Marshaling,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 >*>::marshal(x0); + CasADi::Matrix< CasADi::SX > x1_ = Marshaling,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 >*>::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::marshal(x0); + CasADi::MX x1_ = Marshaling::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::marshal(x0); + CasADi::MX x1_ = Marshaling::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::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::marshal(x0); + CasADi::SX x1_ = Marshaling::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::marshal(x0); + CasADi::SX x1_ = Marshaling::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::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 * x1)" +// params: [Ref (NonVec CSize),ConstRef (Vec (NonVec CInt))] +// args: "(x0_, x1_)" +// cWrapperRetType: "void" +// proto: "void CasADi__hash_combine(size_t* x0, std::vector * x1)" +// call: "CasADi::hash_combine(x0_, x1_)" +extern "C" + void CasADi__hash_combine(size_t* x0, std::vector * x1); +void CasADi__hash_combine(size_t* x0, std::vector * x1){ + size_t x0_ = Marshaling::marshal(x0); + std::vector x1_ = Marshaling,std::vector *>::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 * x2, std::vector * 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 * x2, std::vector * x3)" +// call: "CasADi::hash_sparsity(x0_, x1_, x2_, x3_)" +extern "C" + size_t CasADi__hash_sparsity(int x0, int x1, std::vector * x2, std::vector * x3); +size_t CasADi__hash_sparsity(int x0, int x1, std::vector * x2, std::vector * x3){ + int x0_ = Marshaling::marshal(x0); + int x1_ = Marshaling::marshal(x1); + std::vector x2_ = Marshaling,std::vector *>::marshal(x2); + std::vector x3_ = Marshaling,std::vector *>::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::marshal(x0); + int x1_ = Marshaling::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::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::marshal(x0); + int x1_ = Marshaling::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::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::marshal(x0); + int x1_ = Marshaling::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::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::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::marshal(x0); + int x1_ = Marshaling::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::marshal(x0); + int x1_ = Marshaling::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 * x0, std::vector * 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 * x0, std::vector * x1, int x2, int x3)" +// call: "CasADi::sp_rowcol(x0_, x1_, x2_, x3_)" +extern "C" + CasADi::CRSSparsity* CasADi__sp_rowcol(std::vector * x0, std::vector * x1, int x2, int x3); +CasADi::CRSSparsity* CasADi__sp_rowcol(std::vector * x0, std::vector * x1, int x2, int x3){ + std::vector x0_ = Marshaling,std::vector *>::marshal(x0); + std::vector x1_ = Marshaling,std::vector *>::marshal(x1); + int x2_ = Marshaling::marshal(x2); + int x3_ = Marshaling::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*" +// proto: "std::vector* CasADi__getNZDense(CasADi::CRSSparsity* x0)" +// call: "CasADi::getNZDense(x0_)" +extern "C" + std::vector* CasADi__getNZDense(CasADi::CRSSparsity* x0); +std::vector* CasADi__getNZDense(CasADi::CRSSparsity* x0){ + CasADi::CRSSparsity x0_ = Marshaling::marshal(x0); + + return new std::vector( 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::marshal(x0); + int x1_ = Marshaling::marshal(x1); + int x2_ = Marshaling::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::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::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::marshal(x0); + bool x1_ = Marshaling::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::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*" +// proto: "std::vector* CasADi__lowerNZ(CasADi::CRSSparsity* x0)" +// call: "CasADi::lowerNZ(x0_)" +extern "C" + std::vector* CasADi__lowerNZ(CasADi::CRSSparsity* x0); +std::vector* CasADi__lowerNZ(CasADi::CRSSparsity* x0){ + CasADi::CRSSparsity x0_ = Marshaling::marshal(x0); + + return new std::vector( CasADi::lowerNZ(x0_) ); +} + + +// ================== function "CasADi::sp_triplet" =============== +// cppName: "CasADi::sp_triplet" +// cWrapperName: "CasADi__sp_triplet" +// protoArgs: "(int x0, int x1, std::vector * x2, std::vector * x3, std::vector* 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 * x2, std::vector * x3, std::vector* 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 * x2, std::vector * x3, std::vector* x4, bool* x5); +CasADi::CRSSparsity* CasADi__sp_triplet(int x0, int x1, std::vector * x2, std::vector * x3, std::vector* x4, bool* x5){ + int x0_ = Marshaling::marshal(x0); + int x1_ = Marshaling::marshal(x1); + std::vector x2_ = Marshaling,std::vector *>::marshal(x2); + std::vector x3_ = Marshaling,std::vector *>::marshal(x3); + std::vector x4_ = Marshaling,std::vector*>::marshal(x4); + bool x5_ = Marshaling::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 * x2, std::vector * x3, std::vector* 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 * x2, std::vector * x3, std::vector* x4)" +// call: "CasADi::sp_triplet(x0_, x1_, x2_, x3_, x4_)" +extern "C" + CasADi::CRSSparsity* CasADi__sp_triplet_TIC(int x0, int x1, std::vector * x2, std::vector * x3, std::vector* x4); +CasADi::CRSSparsity* CasADi__sp_triplet_TIC(int x0, int x1, std::vector * x2, std::vector * x3, std::vector* x4){ + int x0_ = Marshaling::marshal(x0); + int x1_ = Marshaling::marshal(x1); + std::vector x2_ = Marshaling,std::vector *>::marshal(x2); + std::vector x3_ = Marshaling,std::vector *>::marshal(x3); + std::vector x4_ = Marshaling,std::vector*>::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 * x2, std::vector * 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 * x2, std::vector * x3)" +// call: "CasADi::sp_triplet(x0_, x1_, x2_, x3_)" +extern "C" + CasADi::CRSSparsity* CasADi__sp_triplet_TIC_TIC(int x0, int x1, std::vector * x2, std::vector * x3); +CasADi::CRSSparsity* CasADi__sp_triplet_TIC_TIC(int x0, int x1, std::vector * x2, std::vector * x3){ + int x0_ = Marshaling::marshal(x0); + int x1_ = Marshaling::marshal(x1); + std::vector x2_ = Marshaling,std::vector *>::marshal(x2); + std::vector x3_ = Marshaling,std::vector *>::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::marshal(x0); + CasADi::CRSSparsity x1_ = Marshaling::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 * x0)" +// params: [ConstRef (Vec (NonVec (CasadiClass CRSSparsity)))] +// args: "(x0_)" +// cWrapperRetType: "CasADi::CRSSparsity*" +// proto: "CasADi::CRSSparsity* CasADi__vertcat_TIC_TIC_TIC(std::vector * x0)" +// call: "CasADi::vertcat(x0_)" +extern "C" + CasADi::CRSSparsity* CasADi__vertcat_TIC_TIC_TIC(std::vector * x0); +CasADi::CRSSparsity* CasADi__vertcat_TIC_TIC_TIC(std::vector * x0){ + std::vector x0_ = Marshaling,std::vector *>::marshal(x0); + + return new CasADi::CRSSparsity( CasADi::vertcat(x0_) ); +} + + +// ================== function "CasADi::horzcat'''" =============== +// cppName: "CasADi::horzcat'''" +// cWrapperName: "CasADi__horzcat_TIC_TIC_TIC" +// protoArgs: "(std::vector * x0)" +// params: [ConstRef (Vec (NonVec (CasadiClass CRSSparsity)))] +// args: "(x0_)" +// cWrapperRetType: "CasADi::CRSSparsity*" +// proto: "CasADi::CRSSparsity* CasADi__horzcat_TIC_TIC_TIC(std::vector * x0)" +// call: "CasADi::horzcat(x0_)" +extern "C" + CasADi::CRSSparsity* CasADi__horzcat_TIC_TIC_TIC(std::vector * x0); +CasADi::CRSSparsity* CasADi__horzcat_TIC_TIC_TIC(std::vector * x0){ + std::vector x0_ = Marshaling,std::vector *>::marshal(x0); + + return new CasADi::CRSSparsity( CasADi::horzcat(x0_) ); +} + + +// ================== function "CasADi::blkdiag'''" =============== +// cppName: "CasADi::blkdiag'''" +// cWrapperName: "CasADi__blkdiag_TIC_TIC_TIC" +// protoArgs: "(std::vector * x0)" +// params: [ConstRef (Vec (NonVec (CasadiClass CRSSparsity)))] +// args: "(x0_)" +// cWrapperRetType: "CasADi::CRSSparsity*" +// proto: "CasADi::CRSSparsity* CasADi__blkdiag_TIC_TIC_TIC(std::vector * x0)" +// call: "CasADi::blkdiag(x0_)" +extern "C" + CasADi::CRSSparsity* CasADi__blkdiag_TIC_TIC_TIC(std::vector * x0); +CasADi::CRSSparsity* CasADi__blkdiag_TIC_TIC_TIC(std::vector * x0){ + std::vector x0_ = Marshaling,std::vector *>::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*" +// proto: "std::vector* CasADi__sp_compress(CasADi::CRSSparsity* x0)" +// call: "CasADi::sp_compress(x0_)" +extern "C" + std::vector* CasADi__sp_compress(CasADi::CRSSparsity* x0); +std::vector* CasADi__sp_compress(CasADi::CRSSparsity* x0){ + CasADi::CRSSparsity x0_ = Marshaling::marshal(x0); + + return new std::vector( CasADi::sp_compress(x0_) ); +} + + +// ================== function "CasADi::sp_compress'" =============== +// cppName: "CasADi::sp_compress'" +// cWrapperName: "CasADi__sp_compress_TIC" +// protoArgs: "(std::vector * x0)" +// params: [ConstRef (Vec (NonVec CInt))] +// args: "(x0_)" +// cWrapperRetType: "CasADi::CRSSparsity*" +// proto: "CasADi::CRSSparsity* CasADi__sp_compress_TIC(std::vector * x0)" +// call: "CasADi::sp_compress(x0_)" +extern "C" + CasADi::CRSSparsity* CasADi__sp_compress_TIC(std::vector * x0); +CasADi::CRSSparsity* CasADi__sp_compress_TIC(std::vector * x0){ + std::vector x0_ = Marshaling,std::vector *>::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::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::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::marshal(x0); + int x1_ = Marshaling::marshal(x1); + int x2_ = Marshaling::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::marshal(x0); + int x1_ = Marshaling::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::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 >*" +// proto: "std::vector >* CasADi__ssym_TIC_TIC_TIC(std::string* x0, CasADi::CRSSparsity* x1, int x2)" +// call: "CasADi::ssym(x0_, x1_, x2_)" +extern "C" + std::vector >* CasADi__ssym_TIC_TIC_TIC(std::string* x0, CasADi::CRSSparsity* x1, int x2); +std::vector >* CasADi__ssym_TIC_TIC_TIC(std::string* x0, CasADi::CRSSparsity* x1, int x2){ + std::string x0_ = Marshaling::marshal(x0); + CasADi::CRSSparsity x1_ = Marshaling::marshal(x1); + int x2_ = Marshaling::marshal(x2); + + return new std::vector >( 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 >*" +// proto: "std::vector >* 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__ssym_TIC_TIC_TIC_TIC(std::string* x0, int x1, int x2, int x3); +std::vector >* CasADi__ssym_TIC_TIC_TIC_TIC(std::string* x0, int x1, int x2, int x3){ + std::string x0_ = Marshaling::marshal(x0); + int x1_ = Marshaling::marshal(x1); + int x2_ = Marshaling::marshal(x2); + int x3_ = Marshaling::marshal(x3); + + return new std::vector >( 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 > >*" +// proto: "std::vector > >* 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 > >* CasADi__ssym_TIC_TIC_TIC_TIC_TIC(std::string* x0, CasADi::CRSSparsity* x1, int x2, int x3); +std::vector > >* CasADi__ssym_TIC_TIC_TIC_TIC_TIC(std::string* x0, CasADi::CRSSparsity* x1, int x2, int x3){ + std::string x0_ = Marshaling::marshal(x0); + CasADi::CRSSparsity x1_ = Marshaling::marshal(x1); + int x2_ = Marshaling::marshal(x2); + int x3_ = Marshaling::marshal(x3); + + return new std::vector > >( 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 > >*" +// proto: "std::vector > >* 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 > >* CasADi__ssym_TIC_TIC_TIC_TIC_TIC_TIC(std::string* x0, int x1, int x2, int x3, int x4); +std::vector > >* CasADi__ssym_TIC_TIC_TIC_TIC_TIC_TIC(std::string* x0, int x1, int x2, int x3, int x4){ + std::string x0_ = Marshaling::marshal(x0); + int x1_ = Marshaling::marshal(x1); + int x2_ = Marshaling::marshal(x2); + int x3_ = Marshaling::marshal(x3); + int x4_ = Marshaling::marshal(x4); + + return new std::vector > >( 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::marshal(x0); + CasADi::CRSSparsity x1_ = Marshaling::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 >*>::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 >*>::marshal(x0); + CasADi::Matrix< CasADi::SX > x1_ = Marshaling,CasADi::Matrix< CasADi::SX >*>::marshal(x1); + CasADi::Matrix< CasADi::SX > x2_ = Marshaling,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::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 >*>::marshal(x0); + CasADi::Matrix< CasADi::SX > x1_ = Marshaling,CasADi::Matrix< CasADi::SX >*>::marshal(x1); + CasADi::Matrix< CasADi::SX > x2_ = Marshaling,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::marshal(x0); + CasADi::Matrix< CasADi::SX > x1_ = Marshaling,CasADi::Matrix< CasADi::SX >*>::marshal(x1); + CasADi::Matrix< CasADi::SX > x2_ = Marshaling,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 >*>::marshal(x0); + CasADi::Matrix< CasADi::SX > x1_ = Marshaling,CasADi::Matrix< CasADi::SX >*>::marshal(x1); + CasADi::Matrix< CasADi::SX > x2_ = Marshaling,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 >*>::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 >*>::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 >*>::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 >*>::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 >*>::marshal(x0); + CasADi::Matrix< CasADi::SX > x1_ = Marshaling,CasADi::Matrix< CasADi::SX >*>::marshal(x1); + CasADi::Matrix< CasADi::SX > x2_ = Marshaling,CasADi::Matrix< CasADi::SX >*>::marshal(x2); + CasADi::Matrix< CasADi::SX > x3_ = Marshaling,CasADi::Matrix< CasADi::SX >*>::marshal(x3); + int x4_ = Marshaling::marshal(x4); + CasADi::Matrix< CasADi::SX > x5_ = Marshaling,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 >*>::marshal(x0); + CasADi::Matrix< CasADi::SX > x1_ = Marshaling,CasADi::Matrix< CasADi::SX >*>::marshal(x1); + CasADi::Matrix< CasADi::SX > x2_ = Marshaling,CasADi::Matrix< CasADi::SX >*>::marshal(x2); + CasADi::Matrix< CasADi::SX > x3_ = Marshaling,CasADi::Matrix< CasADi::SX >*>::marshal(x3); + int x4_ = Marshaling::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 >*>::marshal(x0); + CasADi::Matrix< CasADi::SX > x1_ = Marshaling,CasADi::Matrix< CasADi::SX >*>::marshal(x1); + CasADi::Matrix< CasADi::SX > x2_ = Marshaling,CasADi::Matrix< CasADi::SX >*>::marshal(x2); + CasADi::Matrix< CasADi::SX > x3_ = Marshaling,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 >*>::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 >*>::marshal(x0); + int x1_ = Marshaling::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 >*>::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 >*>::marshal(x0); + CasADi::Matrix< CasADi::SX > x1_ = Marshaling,CasADi::Matrix< CasADi::SX >*>::marshal(x1); + CasADi::Matrix< CasADi::SX > x2_ = Marshaling,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* > * x0, std::vector* > * x1, std::vector* > * x2)" +// params: [ConstRef (Vec (NonVec (CasadiClass SXMatrix))),ConstRef (Vec (NonVec (CasadiClass SXMatrix))),ConstRef (Vec (NonVec (CasadiClass SXMatrix)))] +// args: "(x0_, x1_, x2_)" +// cWrapperRetType: "std::vector >*" +// proto: "std::vector >* CasADi__substitute_TIC(std::vector* > * x0, std::vector* > * x1, std::vector* > * x2)" +// call: "CasADi::substitute(x0_, x1_, x2_)" +extern "C" + std::vector >* CasADi__substitute_TIC(std::vector* > * x0, std::vector* > * x1, std::vector* > * x2); +std::vector >* CasADi__substitute_TIC(std::vector* > * x0, std::vector* > * x1, std::vector* > * x2){ + std::vector > x0_ = Marshaling >,std::vector* > *>::marshal(x0); + std::vector > x1_ = Marshaling >,std::vector* > *>::marshal(x1); + std::vector > x2_ = Marshaling >,std::vector* > *>::marshal(x2); + + return new std::vector >( 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 >*>::marshal(x0); + CasADi::Matrix< CasADi::SX > x1_ = Marshaling,CasADi::Matrix< CasADi::SX >*>::marshal(x1); + bool x2_ = Marshaling::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 >*>::marshal(x0); + CasADi::Matrix< CasADi::SX > x1_ = Marshaling,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* >* 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* >* 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* >* x2, bool* x3); +void CasADi__substituteInPlace_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, std::vector* >* x2, bool* x3){ + CasADi::Matrix< CasADi::SX > x0_ = Marshaling,CasADi::Matrix< CasADi::SX >*>::marshal(x0); + CasADi::Matrix< CasADi::SX > x1_ = Marshaling,CasADi::Matrix< CasADi::SX >*>::marshal(x1); + std::vector > x2_ = Marshaling >,std::vector* >*>::marshal(x2); + bool x3_ = Marshaling::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* >* 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* >* 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* >* x2); +void CasADi__substituteInPlace_TIC_TIC_TIC(CasADi::Matrix< CasADi::SX >* x0, CasADi::Matrix< CasADi::SX >* x1, std::vector* >* x2){ + CasADi::Matrix< CasADi::SX > x0_ = Marshaling,CasADi::Matrix< CasADi::SX >*>::marshal(x0); + CasADi::Matrix< CasADi::SX > x1_ = Marshaling,CasADi::Matrix< CasADi::SX >*>::marshal(x1); + std::vector > x2_ = Marshaling >,std::vector* >*>::marshal(x2); + + return CasADi::substituteInPlace(x0_, x1_, x2_); +} + + +// ================== function "CasADi::substituteInPlace''''" =============== +// cppName: "CasADi::substituteInPlace''''" +// cWrapperName: "CasADi__substituteInPlace_TIC_TIC_TIC_TIC" +// protoArgs: "(std::vector* > * x0, std::vector* >* x1, std::vector* >* 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* > * x0, std::vector* >* x1, std::vector* >* x2, bool* x3)" +// call: "CasADi::substituteInPlace(x0_, x1_, x2_, x3_)" +extern "C" + void CasADi__substituteInPlace_TIC_TIC_TIC_TIC(std::vector* > * x0, std::vector* >* x1, std::vector* >* x2, bool* x3); +void CasADi__substituteInPlace_TIC_TIC_TIC_TIC(std::vector* > * x0, std::vector* >* x1, std::vector* >* x2, bool* x3){ + std::vector > x0_ = Marshaling >,std::vector* > *>::marshal(x0); + std::vector > x1_ = Marshaling >,std::vector* >*>::marshal(x1); + std::vector > x2_ = Marshaling >,std::vector* >*>::marshal(x2); + bool x3_ = Marshaling::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* > * x0, std::vector* >* x1, std::vector* >* 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* > * x0, std::vector* >* x1, std::vector* >* x2)" +// call: "CasADi::substituteInPlace(x0_, x1_, x2_)" +extern "C" + void CasADi__substituteInPlace_TIC_TIC_TIC_TIC_TIC(std::vector* > * x0, std::vector* >* x1, std::vector* >* x2); +void CasADi__substituteInPlace_TIC_TIC_TIC_TIC_TIC(std::vector* > * x0, std::vector* >* x1, std::vector* >* x2){ + std::vector > x0_ = Marshaling >,std::vector* > *>::marshal(x0); + std::vector > x1_ = Marshaling >,std::vector* >*>::marshal(x1); + std::vector > x2_ = Marshaling >,std::vector* >*>::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 >*>::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 >*>::marshal(x0); + CasADi::Matrix< CasADi::SX > x1_ = Marshaling,CasADi::Matrix< CasADi::SX >*>::marshal(x1); + CasADi::Matrix< double > x2_ = Marshaling,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::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 >*>::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 >*>::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 >*>::marshal(x0); + CasADi::Matrix< CasADi::SX > x1_ = Marshaling,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*" +// proto: "std::vector* CasADi__getSymbols(CasADi::Matrix< CasADi::SX >* x0)" +// call: "CasADi::getSymbols(x0_)" +extern "C" + std::vector* CasADi__getSymbols(CasADi::Matrix< CasADi::SX >* x0); +std::vector* CasADi__getSymbols(CasADi::Matrix< CasADi::SX >* x0){ + CasADi::Matrix< CasADi::SX > x0_ = Marshaling,CasADi::Matrix< CasADi::SX >*>::marshal(x0); + + return new std::vector( 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 >*>::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 >*>::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 >*>::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 >*>::marshal(x0); + CasADi::Matrix< CasADi::SX > x1_ = Marshaling,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 >*>::marshal(x0); + CasADi::Matrix< CasADi::SX > x1_ = Marshaling,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 >*>::marshal(x0); + CasADi::Matrix< CasADi::SX > x1_ = Marshaling,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 >*>::marshal(x0); + CasADi::Matrix< CasADi::SX > x1_ = Marshaling,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 >*>::marshal(x0); + CasADi::Matrix< CasADi::SX > x1_ = Marshaling,CasADi::Matrix< CasADi::SX >*>::marshal(x1); + CasADi::Matrix< CasADi::SX > x2_ = Marshaling,CasADi::Matrix< CasADi::SX >*>::marshal(x2); + CasADi::Matrix< CasADi::SX > x3_ = Marshaling,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 >*>::marshal(x0); + CasADi::Matrix< CasADi::SX > x1_ = Marshaling,CasADi::Matrix< CasADi::SX >*>::marshal(x1); + CasADi::Matrix< CasADi::SX > x2_ = Marshaling,CasADi::Matrix< CasADi::SX >*>::marshal(x2); + bool x3_ = Marshaling::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 >*>::marshal(x0); + CasADi::Matrix< CasADi::SX > x1_ = Marshaling,CasADi::Matrix< CasADi::SX >*>::marshal(x1); + CasADi::Matrix< CasADi::SX > x2_ = Marshaling,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 >*>::marshal(x0); + int x1_ = Marshaling::marshal(x1); + int x2_ = Marshaling::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 >*>::marshal(x0); + int x1_ = Marshaling::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 >*>::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 >*>::marshal(x0); + int x1_ = Marshaling::marshal(x1); + int x2_ = Marshaling::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 >*>::marshal(x0); + int x1_ = Marshaling::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 >*>::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 >*>::marshal(x0); + CasADi::SX x1_ = Marshaling::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 >*>::marshal(x0); + CasADi::Matrix< CasADi::SX > x1_ = Marshaling,CasADi::Matrix< CasADi::SX >*>::marshal(x1); + CasADi::Matrix< CasADi::SX > x2_ = Marshaling,CasADi::Matrix< CasADi::SX >*>::marshal(x2); + int x3_ = Marshaling::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 >*>::marshal(x0); + CasADi::Matrix< CasADi::SX > x1_ = Marshaling,CasADi::Matrix< CasADi::SX >*>::marshal(x1); + CasADi::Matrix< CasADi::SX > x2_ = Marshaling,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 >*>::marshal(x0); + CasADi::Matrix< CasADi::SX > x1_ = Marshaling,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 >*>::marshal(x0); + CasADi::Matrix< CasADi::SX > x1_ = Marshaling,CasADi::Matrix< CasADi::SX >*>::marshal(x1); + CasADi::Matrix< CasADi::SX > x2_ = Marshaling,CasADi::Matrix< CasADi::SX >*>::marshal(x2); + int x3_ = Marshaling::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 >*>::marshal(x0); + CasADi::Matrix< CasADi::SX > x1_ = Marshaling,CasADi::Matrix< CasADi::SX >*>::marshal(x1); + CasADi::Matrix< CasADi::SX > x2_ = Marshaling,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 * 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 * 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 * 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 * x4){ + CasADi::Matrix< CasADi::SX > x0_ = Marshaling,CasADi::Matrix< CasADi::SX >*>::marshal(x0); + CasADi::Matrix< CasADi::SX > x1_ = Marshaling,CasADi::Matrix< CasADi::SX >*>::marshal(x1); + CasADi::Matrix< CasADi::SX > x2_ = Marshaling,CasADi::Matrix< CasADi::SX >*>::marshal(x2); + int x3_ = Marshaling::marshal(x3); + std::vector x4_ = Marshaling,std::vector *>::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 >*>::marshal(x0); + + return CasADi::countNodes(x0_); +} + + +// ================== function "CasADi::getOperatorRepresentation" =============== +// cppName: "CasADi::getOperatorRepresentation" +// cWrapperName: "CasADi__getOperatorRepresentation" +// protoArgs: "(CasADi::SX* x0, std::vector * 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 * x1)" +// call: "CasADi::getOperatorRepresentation(x0_, x1_)" +extern "C" + std::string* CasADi__getOperatorRepresentation(CasADi::SX* x0, std::vector * x1); +std::string* CasADi__getOperatorRepresentation(CasADi::SX* x0, std::vector * x1){ + CasADi::SX x0_ = Marshaling::marshal(x0); + std::vector x1_ = Marshaling,std::vector *>::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 >*>::marshal(x0); + + return new CasADi::Matrix< CasADi::SX >( CasADi::getFree(x0_) ); +} + + +// ================== function "CasADi::extractShared" =============== +// cppName: "CasADi::extractShared" +// cWrapperName: "CasADi__extractShared" +// protoArgs: "(std::vector* x0, std::vector* x1, std::vector* 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* x0, std::vector* x1, std::vector* x2, std::string* x3, std::string* x4)" +// call: "CasADi::extractShared(x0_, x1_, x2_, x3_, x4_)" +extern "C" + void CasADi__extractShared(std::vector* x0, std::vector* x1, std::vector* x2, std::string* x3, std::string* x4); +void CasADi__extractShared(std::vector* x0, std::vector* x1, std::vector* x2, std::string* x3, std::string* x4){ + std::vector x0_ = Marshaling,std::vector*>::marshal(x0); + std::vector x1_ = Marshaling,std::vector*>::marshal(x1); + std::vector x2_ = Marshaling,std::vector*>::marshal(x2); + std::string x3_ = Marshaling::marshal(x3); + std::string x4_ = Marshaling::marshal(x4); + + return CasADi::extractShared(x0_, x1_, x2_, x3_, x4_); +} + + +// ================== function "CasADi::extractShared'" =============== +// cppName: "CasADi::extractShared'" +// cWrapperName: "CasADi__extractShared_TIC" +// protoArgs: "(std::vector* x0, std::vector* x1, std::vector* 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* x0, std::vector* x1, std::vector* x2, std::string* x3)" +// call: "CasADi::extractShared(x0_, x1_, x2_, x3_)" +extern "C" + void CasADi__extractShared_TIC(std::vector* x0, std::vector* x1, std::vector* x2, std::string* x3); +void CasADi__extractShared_TIC(std::vector* x0, std::vector* x1, std::vector* x2, std::string* x3){ + std::vector x0_ = Marshaling,std::vector*>::marshal(x0); + std::vector x1_ = Marshaling,std::vector*>::marshal(x1); + std::vector x2_ = Marshaling,std::vector*>::marshal(x2); + std::string x3_ = Marshaling::marshal(x3); + + return CasADi::extractShared(x0_, x1_, x2_, x3_); +} + + +// ================== function "CasADi::extractShared''" =============== +// cppName: "CasADi::extractShared''" +// cWrapperName: "CasADi__extractShared_TIC_TIC" +// protoArgs: "(std::vector* x0, std::vector* x1, std::vector* 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* x0, std::vector* x1, std::vector* x2)" +// call: "CasADi::extractShared(x0_, x1_, x2_)" +extern "C" + void CasADi__extractShared_TIC_TIC(std::vector* x0, std::vector* x1, std::vector* x2); +void CasADi__extractShared_TIC_TIC(std::vector* x0, std::vector* x1, std::vector* x2){ + std::vector x0_ = Marshaling,std::vector*>::marshal(x0); + std::vector x1_ = Marshaling,std::vector*>::marshal(x1); + std::vector x2_ = Marshaling,std::vector*>::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 >*>::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 >*>::marshal(x0); + CasADi::Matrix< CasADi::SX > x1_ = Marshaling,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 >*>::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 >*>::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 * x0)" +// params: [ConstRef (Vec (NonVec (CasadiClass MX)))] +// args: "(x0_)" +// cWrapperRetType: "CasADi::MX*" +// proto: "CasADi::MX* CasADi__vertcat_TIC_TIC_TIC_TIC(std::vector * x0)" +// call: "CasADi::vertcat(x0_)" +extern "C" + CasADi::MX* CasADi__vertcat_TIC_TIC_TIC_TIC(std::vector * x0); +CasADi::MX* CasADi__vertcat_TIC_TIC_TIC_TIC(std::vector * x0){ + std::vector x0_ = Marshaling,std::vector *>::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 * x1)" +// params: [ConstRef (NonVec (CasadiClass MX)),ConstRef (Vec (NonVec CInt))] +// args: "(x0_, x1_)" +// cWrapperRetType: "std::vector*" +// proto: "std::vector* CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0, std::vector * x1)" +// call: "CasADi::vertsplit(x0_, x1_)" +extern "C" + std::vector* CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0, std::vector * x1); +std::vector* CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0, std::vector * x1){ + CasADi::MX x0_ = Marshaling::marshal(x0); + std::vector x1_ = Marshaling,std::vector *>::marshal(x1); + + return new std::vector( 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*" +// proto: "std::vector* 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__vertsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0, int x1); +std::vector* CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0, int x1){ + CasADi::MX x0_ = Marshaling::marshal(x0); + int x1_ = Marshaling::marshal(x1); + + return new std::vector( 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*" +// proto: "std::vector* 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__vertsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0); +std::vector* CasADi__vertsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0){ + CasADi::MX x0_ = Marshaling::marshal(x0); + + return new std::vector( CasADi::vertsplit(x0_) ); +} + + +// ================== function "CasADi::horzcat''''" =============== +// cppName: "CasADi::horzcat''''" +// cWrapperName: "CasADi__horzcat_TIC_TIC_TIC_TIC" +// protoArgs: "(std::vector * x0)" +// params: [ConstRef (Vec (NonVec (CasadiClass MX)))] +// args: "(x0_)" +// cWrapperRetType: "CasADi::MX*" +// proto: "CasADi::MX* CasADi__horzcat_TIC_TIC_TIC_TIC(std::vector * x0)" +// call: "CasADi::horzcat(x0_)" +extern "C" + CasADi::MX* CasADi__horzcat_TIC_TIC_TIC_TIC(std::vector * x0); +CasADi::MX* CasADi__horzcat_TIC_TIC_TIC_TIC(std::vector * x0){ + std::vector x0_ = Marshaling,std::vector *>::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 * x1)" +// params: [ConstRef (NonVec (CasadiClass MX)),ConstRef (Vec (NonVec CInt))] +// args: "(x0_, x1_)" +// cWrapperRetType: "std::vector*" +// proto: "std::vector* CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0, std::vector * x1)" +// call: "CasADi::horzsplit(x0_, x1_)" +extern "C" + std::vector* CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0, std::vector * x1); +std::vector* CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0, std::vector * x1){ + CasADi::MX x0_ = Marshaling::marshal(x0); + std::vector x1_ = Marshaling,std::vector *>::marshal(x1); + + return new std::vector( 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*" +// proto: "std::vector* 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__horzsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0, int x1); +std::vector* CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0, int x1){ + CasADi::MX x0_ = Marshaling::marshal(x0); + int x1_ = Marshaling::marshal(x1); + + return new std::vector( 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*" +// proto: "std::vector* 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__horzsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0); +std::vector* CasADi__horzsplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0){ + CasADi::MX x0_ = Marshaling::marshal(x0); + + return new std::vector( CasADi::horzsplit(x0_) ); +} + + +// ================== function "CasADi::blockcat'''" =============== +// cppName: "CasADi::blockcat'''" +// cWrapperName: "CasADi__blockcat_TIC_TIC_TIC" +// protoArgs: "(std::vector > * x0)" +// params: [ConstRef (Vec (Vec (NonVec (CasadiClass MX))))] +// args: "(x0_)" +// cWrapperRetType: "CasADi::MX*" +// proto: "CasADi::MX* CasADi__blockcat_TIC_TIC_TIC(std::vector > * x0)" +// call: "CasADi::blockcat(x0_)" +extern "C" + CasADi::MX* CasADi__blockcat_TIC_TIC_TIC(std::vector > * x0); +CasADi::MX* CasADi__blockcat_TIC_TIC_TIC(std::vector > * x0){ + std::vector > x0_ = Marshaling >,std::vector > *>::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 * x1, std::vector * x2)" +// params: [ConstRef (NonVec (CasadiClass MX)),ConstRef (Vec (NonVec CInt)),ConstRef (Vec (NonVec CInt))] +// args: "(x0_, x1_, x2_)" +// cWrapperRetType: "std::vector >*" +// proto: "std::vector >* CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0, std::vector * x1, std::vector * x2)" +// call: "CasADi::blocksplit(x0_, x1_, x2_)" +extern "C" + std::vector >* CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0, std::vector * x1, std::vector * x2); +std::vector >* CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0, std::vector * x1, std::vector * x2){ + CasADi::MX x0_ = Marshaling::marshal(x0); + std::vector x1_ = Marshaling,std::vector *>::marshal(x1); + std::vector x2_ = Marshaling,std::vector *>::marshal(x2); + + return new std::vector >( 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 >*" +// proto: "std::vector >* 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 >* CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0, int x1, int x2); +std::vector >* 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::marshal(x0); + int x1_ = Marshaling::marshal(x1); + int x2_ = Marshaling::marshal(x2); + + return new std::vector >( 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 >*" +// proto: "std::vector >* 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 >* CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0, int x1); +std::vector >* 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::marshal(x0); + int x1_ = Marshaling::marshal(x1); + + return new std::vector >( 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 >*" +// proto: "std::vector >* 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 >* CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0); +std::vector >* CasADi__blocksplit_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(CasADi::MX* x0){ + CasADi::MX x0_ = Marshaling::marshal(x0); + + return new std::vector >( CasADi::blocksplit(x0_) ); +} + + +// ================== function "CasADi::veccat'''" =============== +// cppName: "CasADi::veccat'''" +// cWrapperName: "CasADi__veccat_TIC_TIC_TIC" +// protoArgs: "(std::vector * x0)" +// params: [ConstRef (Vec (NonVec (CasadiClass MX)))] +// args: "(x0_)" +// cWrapperRetType: "CasADi::MX*" +// proto: "CasADi::MX* CasADi__veccat_TIC_TIC_TIC(std::vector * x0)" +// call: "CasADi::veccat(x0_)" +extern "C" + CasADi::MX* CasADi__veccat_TIC_TIC_TIC(std::vector * x0); +CasADi::MX* CasADi__veccat_TIC_TIC_TIC(std::vector * x0){ + std::vector x0_ = Marshaling,std::vector *>::marshal(x0); + + return new CasADi::MX( CasADi::veccat(x0_) ); +} + + +// ================== function "CasADi::flattencat'''" =============== +// cppName: "CasADi::flattencat'''" +// cWrapperName: "CasADi__flattencat_TIC_TIC_TIC" +// protoArgs: "(std::vector * x0)" +// params: [ConstRef (Vec (NonVec (CasadiClass MX)))] +// args: "(x0_)" +// cWrapperRetType: "CasADi::MX*" +// proto: "CasADi::MX* CasADi__flattencat_TIC_TIC_TIC(std::vector * x0)" +// call: "CasADi::flattencat(x0_)" +extern "C" + CasADi::MX* CasADi__flattencat_TIC_TIC_TIC(std::vector * x0); +CasADi::MX* CasADi__flattencat_TIC_TIC_TIC(std::vector * x0){ + std::vector x0_ = Marshaling,std::vector *>::marshal(x0); + + return new CasADi::MX( CasADi::flattencat(x0_) ); +} + + +// ================== function "CasADi::vecNZcat'''" =============== +// cppName: "CasADi::vecNZcat'''" +// cWrapperName: "CasADi__vecNZcat_TIC_TIC_TIC" +// protoArgs: "(std::vector * x0)" +// params: [ConstRef (Vec (NonVec (CasadiClass MX)))] +// args: "(x0_)" +// cWrapperRetType: "CasADi::MX*" +// proto: "CasADi::MX* CasADi__vecNZcat_TIC_TIC_TIC(std::vector * x0)" +// call: "CasADi::vecNZcat(x0_)" +extern "C" + CasADi::MX* CasADi__vecNZcat_TIC_TIC_TIC(std::vector * x0); +CasADi::MX* CasADi__vecNZcat_TIC_TIC_TIC(std::vector * x0){ + std::vector x0_ = Marshaling,std::vector *>::marshal(x0); + + return new CasADi::MX( CasADi::vecNZcat(x0_) ); +} + + +// ================== function "CasADi::flattenNZcat'''" =============== +// cppName: "CasADi::flattenNZcat'''" +// cWrapperName: "CasADi__flattenNZcat_TIC_TIC_TIC" +// protoArgs: "(std::vector * x0)" +// params: [ConstRef (Vec (NonVec (CasadiClass MX)))] +// args: "(x0_)" +// cWrapperRetType: "CasADi::MX*" +// proto: "CasADi::MX* CasADi__flattenNZcat_TIC_TIC_TIC(std::vector * x0)" +// call: "CasADi::flattenNZcat(x0_)" +extern "C" + CasADi::MX* CasADi__flattenNZcat_TIC_TIC_TIC(std::vector * x0); +CasADi::MX* CasADi__flattenNZcat_TIC_TIC_TIC(std::vector * x0){ + std::vector x0_ = Marshaling,std::vector *>::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::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::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::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::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::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::marshal(x0); + CasADi::MX x1_ = Marshaling::marshal(x1); + CasADi::CRSSparsity x2_ = Marshaling::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::marshal(x0); + CasADi::MX x1_ = Marshaling::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 * 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 * 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 * x0); +CasADi::MX* CasADi__mul_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector * x0){ + std::vector x0_ = Marshaling,std::vector *>::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::marshal(x0); + CasADi::MX x1_ = Marshaling::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::marshal(x0); + CasADi::MX x1_ = Marshaling::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::marshal(x0); + CasADi::MX x1_ = Marshaling::marshal(x1); + CasADi::MX x2_ = Marshaling::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::marshal(x0); + CasADi::CRSSparsity x1_ = Marshaling::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::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::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::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::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::marshal(x0); + CasADi::MX x1_ = Marshaling::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::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::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::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::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::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::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::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::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::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::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::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::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::marshal(x0); + int x1_ = Marshaling::marshal(x1); + int x2_ = Marshaling::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::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::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::marshal(x0); + + return new CasADi::MX( CasADi::full(x0_) ); +} + + +// ================== function "CasADi::createParent" =============== +// cppName: "CasADi::createParent" +// cWrapperName: "CasADi__createParent" +// protoArgs: "(std::vector* x0)" +// params: [Ref (Vec (NonVec (CasadiClass MX)))] +// args: "(x0_)" +// cWrapperRetType: "CasADi::MX*" +// proto: "CasADi::MX* CasADi__createParent(std::vector* x0)" +// call: "CasADi::createParent(x0_)" +extern "C" + CasADi::MX* CasADi__createParent(std::vector* x0); +CasADi::MX* CasADi__createParent(std::vector* x0){ + std::vector x0_ = Marshaling,std::vector*>::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::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::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 * x0)" +// params: [ConstRef (Vec (NonVec (CasadiClass MX)))] +// args: "(x0_)" +// cWrapperRetType: "CasADi::MX*" +// proto: "CasADi::MX* CasADi__blkdiag_TIC_TIC_TIC_TIC(std::vector * x0)" +// call: "CasADi::blkdiag(x0_)" +extern "C" + CasADi::MX* CasADi__blkdiag_TIC_TIC_TIC_TIC(std::vector * x0); +CasADi::MX* CasADi__blkdiag_TIC_TIC_TIC_TIC(std::vector * x0){ + std::vector x0_ = Marshaling,std::vector *>::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::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::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::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::marshal(x0); + CasADi::MX x1_ = Marshaling::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::marshal(x0); + int x1_ = Marshaling::marshal(x1); + int x2_ = Marshaling::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::marshal(x0); + int x1_ = Marshaling::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::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 >*>::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::marshal(x0); + CasADi::CRSSparsity x1_ = Marshaling::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*" +// proto: "std::vector* 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__msym_TIC_TIC_TIC_TIC_TIC(std::string* x0, CasADi::CRSSparsity* x1, int x2); +std::vector* CasADi__msym_TIC_TIC_TIC_TIC_TIC(std::string* x0, CasADi::CRSSparsity* x1, int x2){ + std::string x0_ = Marshaling::marshal(x0); + CasADi::CRSSparsity x1_ = Marshaling::marshal(x1); + int x2_ = Marshaling::marshal(x2); + + return new std::vector( 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*" +// proto: "std::vector* 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__msym_TIC_TIC_TIC_TIC_TIC_TIC(std::string* x0, int x1, int x2, int x3); +std::vector* CasADi__msym_TIC_TIC_TIC_TIC_TIC_TIC(std::string* x0, int x1, int x2, int x3){ + std::string x0_ = Marshaling::marshal(x0); + int x1_ = Marshaling::marshal(x1); + int x2_ = Marshaling::marshal(x2); + int x3_ = Marshaling::marshal(x3); + + return new std::vector( 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 >*" +// proto: "std::vector >* 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 >* CasADi__msym_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::string* x0, CasADi::CRSSparsity* x1, int x2, int x3); +std::vector >* CasADi__msym_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::string* x0, CasADi::CRSSparsity* x1, int x2, int x3){ + std::string x0_ = Marshaling::marshal(x0); + CasADi::CRSSparsity x1_ = Marshaling::marshal(x1); + int x2_ = Marshaling::marshal(x2); + int x3_ = Marshaling::marshal(x3); + + return new std::vector >( 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 >*" +// proto: "std::vector >* 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 >* CasADi__msym_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::string* x0, int x1, int x2, int x3, int x4); +std::vector >* 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::marshal(x0); + int x1_ = Marshaling::marshal(x1); + int x2_ = Marshaling::marshal(x2); + int x3_ = Marshaling::marshal(x3); + int x4_ = Marshaling::marshal(x4); + + return new std::vector >( 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::marshal(x0); + CasADi::MX x1_ = Marshaling::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 * 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 * x1)" +// call: "CasADi::getOperatorRepresentation(x0_, x1_)" +extern "C" + std::string* CasADi__getOperatorRepresentation_TIC(CasADi::MX* x0, std::vector * x1); +std::string* CasADi__getOperatorRepresentation_TIC(CasADi::MX* x0, std::vector * x1){ + CasADi::MX x0_ = Marshaling::marshal(x0); + std::vector x1_ = Marshaling,std::vector *>::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::marshal(x0); + CasADi::MX x1_ = Marshaling::marshal(x1); + CasADi::MX x2_ = Marshaling::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 * x0, std::vector * x1, std::vector * x2)" +// params: [ConstRef (Vec (NonVec (CasadiClass MX))),ConstRef (Vec (NonVec (CasadiClass MX))),ConstRef (Vec (NonVec (CasadiClass MX)))] +// args: "(x0_, x1_, x2_)" +// cWrapperRetType: "std::vector*" +// proto: "std::vector* CasADi__substitute_TIC_TIC_TIC(std::vector * x0, std::vector * x1, std::vector * x2)" +// call: "CasADi::substitute(x0_, x1_, x2_)" +extern "C" + std::vector* CasADi__substitute_TIC_TIC_TIC(std::vector * x0, std::vector * x1, std::vector * x2); +std::vector* CasADi__substitute_TIC_TIC_TIC(std::vector * x0, std::vector * x1, std::vector * x2){ + std::vector x0_ = Marshaling,std::vector *>::marshal(x0); + std::vector x1_ = Marshaling,std::vector *>::marshal(x1); + std::vector x2_ = Marshaling,std::vector *>::marshal(x2); + + return new std::vector( CasADi::substitute(x0_, x1_, x2_) ); +} + + +// ================== function "CasADi::graph_substitute" =============== +// cppName: "CasADi::graph_substitute" +// cWrapperName: "CasADi__graph_substitute" +// protoArgs: "(CasADi::MX* x0, std::vector * x1, std::vector * 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 * x1, std::vector * x2)" +// call: "CasADi::graph_substitute(x0_, x1_, x2_)" +extern "C" + CasADi::MX* CasADi__graph_substitute(CasADi::MX* x0, std::vector * x1, std::vector * x2); +CasADi::MX* CasADi__graph_substitute(CasADi::MX* x0, std::vector * x1, std::vector * x2){ + CasADi::MX x0_ = Marshaling::marshal(x0); + std::vector x1_ = Marshaling,std::vector *>::marshal(x1); + std::vector x2_ = Marshaling,std::vector *>::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 * x0, std::vector * x1, std::vector * x2)" +// params: [ConstRef (Vec (NonVec (CasadiClass MX))),ConstRef (Vec (NonVec (CasadiClass MX))),ConstRef (Vec (NonVec (CasadiClass MX)))] +// args: "(x0_, x1_, x2_)" +// cWrapperRetType: "std::vector*" +// proto: "std::vector* CasADi__graph_substitute_TIC(std::vector * x0, std::vector * x1, std::vector * x2)" +// call: "CasADi::graph_substitute(x0_, x1_, x2_)" +extern "C" + std::vector* CasADi__graph_substitute_TIC(std::vector * x0, std::vector * x1, std::vector * x2); +std::vector* CasADi__graph_substitute_TIC(std::vector * x0, std::vector * x1, std::vector * x2){ + std::vector x0_ = Marshaling,std::vector *>::marshal(x0); + std::vector x1_ = Marshaling,std::vector *>::marshal(x1); + std::vector x2_ = Marshaling,std::vector *>::marshal(x2); + + return new std::vector( CasADi::graph_substitute(x0_, x1_, x2_) ); +} + + +// ================== function "CasADi::substituteInPlace''''''" =============== +// cppName: "CasADi::substituteInPlace''''''" +// cWrapperName: "CasADi__substituteInPlace_TIC_TIC_TIC_TIC_TIC_TIC" +// protoArgs: "(std::vector * x0, std::vector* 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 * x0, std::vector* x1, bool* x2)" +// call: "CasADi::substituteInPlace(x0_, x1_, x2_)" +extern "C" + void CasADi__substituteInPlace_TIC_TIC_TIC_TIC_TIC_TIC(std::vector * x0, std::vector* x1, bool* x2); +void CasADi__substituteInPlace_TIC_TIC_TIC_TIC_TIC_TIC(std::vector * x0, std::vector* x1, bool* x2){ + std::vector x0_ = Marshaling,std::vector *>::marshal(x0); + std::vector x1_ = Marshaling,std::vector*>::marshal(x1); + bool x2_ = Marshaling::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 * x0, std::vector* 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 * x0, std::vector* x1)" +// call: "CasADi::substituteInPlace(x0_, x1_)" +extern "C" + void CasADi__substituteInPlace_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector * x0, std::vector* x1); +void CasADi__substituteInPlace_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector * x0, std::vector* x1){ + std::vector x0_ = Marshaling,std::vector *>::marshal(x0); + std::vector x1_ = Marshaling,std::vector*>::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 * x0, std::vector* x1, std::vector* 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 * x0, std::vector* x1, std::vector* 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 * x0, std::vector* x1, std::vector* x2, bool* x3); +void CasADi__substituteInPlace_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector * x0, std::vector* x1, std::vector* x2, bool* x3){ + std::vector x0_ = Marshaling,std::vector *>::marshal(x0); + std::vector x1_ = Marshaling,std::vector*>::marshal(x1); + std::vector x2_ = Marshaling,std::vector*>::marshal(x2); + bool x3_ = Marshaling::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 * x0, std::vector* x1, std::vector* 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 * x0, std::vector* x1, std::vector* x2)" +// call: "CasADi::substituteInPlace(x0_, x1_, x2_)" +extern "C" + void CasADi__substituteInPlace_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector * x0, std::vector* x1, std::vector* x2); +void CasADi__substituteInPlace_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC_TIC(std::vector * x0, std::vector* x1, std::vector* x2){ + std::vector x0_ = Marshaling,std::vector *>::marshal(x0); + std::vector x1_ = Marshaling,std::vector*>::marshal(x1); + std::vector x2_ = Marshaling,std::vector*>::marshal(x2); + + return CasADi::substituteInPlace(x0_, x1_, x2_); +} + + +// ================== function "CasADi::extractShared'''" =============== +// cppName: "CasADi::extractShared'''" +// cWrapperName: "CasADi__extractShared_TIC_TIC_TIC" +// protoArgs: "(std::vector* x0, std::vector* x1, std::vector* 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* x0, std::vector* x1, std::vector* 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* x0, std::vector* x1, std::vector* x2, std::string* x3, std::string* x4); +void CasADi__extractShared_TIC_TIC_TIC(std::vector* x0, std::vector* x1, std::vector* x2, std::string* x3, std::string* x4){ + std::vector x0_ = Marshaling,std::vector*>::marshal(x0); + std::vector x1_ = Marshaling,std::vector*>::marshal(x1); + std::vector x2_ = Marshaling,std::vector*>::marshal(x2); + std::string x3_ = Marshaling::marshal(x3); + std::string x4_ = Marshaling::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* x0, std::vector* x1, std::vector* 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* x0, std::vector* x1, std::vector* x2, std::string* x3)" +// call: "CasADi::extractShared(x0_, x1_, x2_, x3_)" +extern "C" + void CasADi__extractShared_TIC_TIC_TIC_TIC(std::vector* x0, std::vector* x1, std::vector* x2, std::string* x3); +void CasADi__extractShared_TIC_TIC_TIC_TIC(std::vector* x0, std::vector* x1, std::vector* x2, std::string* x3){ + std::vector x0_ = Marshaling,std::vector*>::marshal(x0); + std::vector x1_ = Marshaling,std::vector*>::marshal(x1); + std::vector x2_ = Marshaling,std::vector*>::marshal(x2); + std::string x3_ = Marshaling::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* x0, std::vector* x1, std::vector* 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* x0, std::vector* x1, std::vector* x2)" +// call: "CasADi::extractShared(x0_, x1_, x2_)" +extern "C" + void CasADi__extractShared_TIC_TIC_TIC_TIC_TIC(std::vector* x0, std::vector* x1, std::vector* x2); +void CasADi__extractShared_TIC_TIC_TIC_TIC_TIC(std::vector* x0, std::vector* x1, std::vector* x2){ + std::vector x0_ = Marshaling,std::vector*>::marshal(x0); + std::vector x1_ = Marshaling,std::vector*>::marshal(x1); + std::vector x2_ = Marshaling,std::vector*>::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::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::marshal(x0); + CasADi::MX x1_ = Marshaling::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::marshal(x0); + CasADi::MX x1_ = Marshaling::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::marshal(x0); + CasADi::MX x1_ = Marshaling::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::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::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::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*" +// proto: "std::vector* CasADi__getSymbols_TIC(CasADi::MX* x0)" +// call: "CasADi::getSymbols(x0_)" +extern "C" + std::vector* CasADi__getSymbols_TIC(CasADi::MX* x0); +std::vector* CasADi__getSymbols_TIC(CasADi::MX* x0){ + CasADi::MX x0_ = Marshaling::marshal(x0); + + return new std::vector( CasADi::getSymbols(x0_) ); +} + + +// ================== function "CasADi::getSymbols''" =============== +// cppName: "CasADi::getSymbols''" +// cWrapperName: "CasADi__getSymbols_TIC_TIC" +// protoArgs: "(std::vector * x0)" +// params: [ConstRef (Vec (NonVec (CasadiClass MX)))] +// args: "(x0_)" +// cWrapperRetType: "std::vector*" +// proto: "std::vector* CasADi__getSymbols_TIC_TIC(std::vector * x0)" +// call: "CasADi::getSymbols(x0_)" +extern "C" + std::vector* CasADi__getSymbols_TIC_TIC(std::vector * x0); +std::vector* CasADi__getSymbols_TIC_TIC(std::vector * x0){ + std::vector x0_ = Marshaling,std::vector *>::marshal(x0); + + return new std::vector( CasADi::getSymbols(x0_) ); +} + + +// ================== function "CasADi::matrix_expand" =============== +// cppName: "CasADi::matrix_expand" +// cWrapperName: "CasADi__matrix_expand" +// protoArgs: "(CasADi::MX* x0, std::vector * 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 * x1)" +// call: "CasADi::matrix_expand(x0_, x1_)" +extern "C" + CasADi::MX* CasADi__matrix_expand(CasADi::MX* x0, std::vector * x1); +CasADi::MX* CasADi__matrix_expand(CasADi::MX* x0, std::vector * x1){ + CasADi::MX x0_ = Marshaling::marshal(x0); + std::vector x1_ = Marshaling,std::vector *>::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::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 * x0, std::vector * x1)" +// params: [ConstRef (Vec (NonVec (CasadiClass MX))),ConstRef (Vec (NonVec (CasadiClass MX)))] +// args: "(x0_, x1_)" +// cWrapperRetType: "std::vector*" +// proto: "std::vector* CasADi__matrix_expand_TIC_TIC(std::vector * x0, std::vector * x1)" +// call: "CasADi::matrix_expand(x0_, x1_)" +extern "C" + std::vector* CasADi__matrix_expand_TIC_TIC(std::vector * x0, std::vector * x1); +std::vector* CasADi__matrix_expand_TIC_TIC(std::vector * x0, std::vector * x1){ + std::vector x0_ = Marshaling,std::vector *>::marshal(x0); + std::vector x1_ = Marshaling,std::vector *>::marshal(x1); + + return new std::vector( CasADi::matrix_expand(x0_, x1_) ); +} + + +// ================== function "CasADi::matrix_expand'''" =============== +// cppName: "CasADi::matrix_expand'''" +// cWrapperName: "CasADi__matrix_expand_TIC_TIC_TIC" +// protoArgs: "(std::vector * x0)" +// params: [ConstRef (Vec (NonVec (CasadiClass MX)))] +// args: "(x0_)" +// cWrapperRetType: "std::vector*" +// proto: "std::vector* CasADi__matrix_expand_TIC_TIC_TIC(std::vector * x0)" +// call: "CasADi::matrix_expand(x0_)" +extern "C" + std::vector* CasADi__matrix_expand_TIC_TIC_TIC(std::vector * x0); +std::vector* CasADi__matrix_expand_TIC_TIC_TIC(std::vector * x0){ + std::vector x0_ = Marshaling,std::vector *>::marshal(x0); + + return new std::vector( 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::marshal(x0); + CasADi::MX x1_ = Marshaling::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::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::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::marshal(x0); + CasADi::Matrix< double > x1_ = Marshaling,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::marshal(x0); + CasADi::Matrix< double > x1_ = Marshaling,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::marshal(x0); + CasADi::Matrix< double > x1_ = Marshaling,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::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::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*" +// proto: "std::vector* CasADi__collocationPoints(int x0, std::string* x1)" +// call: "CasADi::collocationPoints(x0_, x1_)" +extern "C" + std::vector* CasADi__collocationPoints(int x0, std::string* x1); +std::vector* CasADi__collocationPoints(int x0, std::string* x1){ + int x0_ = Marshaling::marshal(x0); + std::string x1_ = Marshaling::marshal(x1); + + return new std::vector( 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*" +// proto: "std::vector* CasADi__collocationPoints_TIC(int x0)" +// call: "CasADi::collocationPoints(x0_)" +extern "C" + std::vector* CasADi__collocationPoints_TIC(int x0); +std::vector* CasADi__collocationPoints_TIC(int x0){ + int x0_ = Marshaling::marshal(x0); + + return new std::vector( CasADi::collocationPoints(x0_) ); +} + + +// ================== function "CasADi::collocationInterpolators" =============== +// cppName: "CasADi::collocationInterpolators" +// cWrapperName: "CasADi__collocationInterpolators" +// protoArgs: "(std::vector * x0, std::vector >* x1, std::vector* 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 * x0, std::vector >* x1, std::vector* x2)" +// call: "CasADi::collocationInterpolators(x0_, x1_, x2_)" +extern "C" + void CasADi__collocationInterpolators(std::vector * x0, std::vector >* x1, std::vector* x2); +void CasADi__collocationInterpolators(std::vector * x0, std::vector >* x1, std::vector* x2){ + std::vector x0_ = Marshaling,std::vector *>::marshal(x0); + std::vector > x1_ = Marshaling >,std::vector >*>::marshal(x1); + std::vector x2_ = Marshaling,std::vector*>::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::marshal(x0); + CasADi::MX x1_ = Marshaling::marshal(x1); + int x2_ = Marshaling::marshal(x2); + int x3_ = Marshaling::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::marshal(x0); + CasADi::MX x1_ = Marshaling::marshal(x1); + int x2_ = Marshaling::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::marshal(x0); + CasADi::MX x1_ = Marshaling::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::marshal(x0); + + return new CasADi::FX( CasADi::explicitRK(x0_) ); +} + + +// ================== delete CInt=============== +// classType: CInt +extern "C" + void delete_std__vector_int_(std::vector* obj); +void delete_std__vector_int_(std::vector* obj){ + delete obj; +} +extern "C" + void delete_std__vector_std__vector_int__(std::vector >* obj); +void delete_std__vector_std__vector_int__(std::vector >* obj){ + delete obj; +} +extern "C" + void delete_std__vector_std__vector_std__vector_int___(std::vector > >* obj); +void delete_std__vector_std__vector_std__vector_int___(std::vector > >* obj){ + delete obj; +} + +// ================== delete CDouble=============== +// classType: CDouble +extern "C" + void delete_std__vector_double_(std::vector* obj); +void delete_std__vector_double_(std::vector* obj){ + delete obj; +} +extern "C" + void delete_std__vector_std__vector_double__(std::vector >* obj); +void delete_std__vector_std__vector_double__(std::vector >* obj){ + delete obj; +} +extern "C" + void delete_std__vector_std__vector_std__vector_double___(std::vector > >* obj); +void delete_std__vector_std__vector_std__vector_double___(std::vector > >* 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* obj); +void delete_std__vector_std__string_(std::vector* obj){ + delete obj; +} +extern "C" + void delete_std__vector_std__vector_std__string__(std::vector >* obj); +void delete_std__vector_std__vector_std__string__(std::vector >* obj){ + delete obj; +} +extern "C" + void delete_std__vector_std__vector_std__vector_std__string___(std::vector > >* obj); +void delete_std__vector_std__vector_std__vector_std__string___(std::vector > >* 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* obj); +void delete_std__vector_bool_(std::vector* obj){ + delete obj; +} +extern "C" + void delete_std__vector_std__vector_bool__(std::vector >* obj); +void delete_std__vector_std__vector_bool__(std::vector >* obj){ + delete obj; +} +extern "C" + void delete_std__vector_std__vector_std__vector_bool___(std::vector > >* obj); +void delete_std__vector_std__vector_std__vector_bool___(std::vector > >* obj){ + delete obj; +} diff --git a/cbits/callback.cpp b/cbits/callback.cpp new file mode 100644 --- /dev/null +++ b/cbits/callback.cpp @@ -0,0 +1,56 @@ +#include +#include +#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; +} diff --git a/cbits/hs_tools.cpp b/cbits/hs_tools.cpp new file mode 100644 --- /dev/null +++ b/cbits/hs_tools.cpp @@ -0,0 +1,123 @@ +#include +#include +#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 +void hs_vec_copy_T(vector * vec, T outputs[]){ + memcpy(outputs, &((*vec)[0]), vec->size()*sizeof(T)); +} + +// 2d void pointers +template +void hs_vec_vec_sizes_T(vector > * vec, int sizes[]){ + for (unsigned int k=0; ksize(); k++){ + sizes[k] = (*vec)[k].size(); + } +} +template +void hs_vec_vec_copy_T(vector > * vec, T* outputs[]){ + for (unsigned int k=0; ksize(); k++){ + memcpy(outputs[k], &(vec[k][0]), vec[k].size()*sizeof(T)); + } +} + + +////////////////////// CREATING VECTORS FROM ARRAYS /////////////////////////////////// +// 1-dimensional +template +vector * hs_new_vec_T(T inputs[], int length){ + vector vec; + for (int k=0; k(vec); +} + +// 2-dimensional +template +vector > * hs_new_vec_vec_T(T inputs[], int length_outer, int lengths_inner[]){ + vector > vec; + int counter = 0; + for (int k=0; k inner; + for (int j=0; j >(vec); +} + +//////////////////////////////////////////////////////////////////////////////////////////// +#define WRITE_STUFF(name, type) \ + extern "C" vector* hs_new_vec_##name( type inputs[], int length); \ + vector* hs_new_vec_##name( type inputs[], int length){return hs_new_vec_T(inputs, length);} \ + extern "C" void hs_delete_vec_##name(vector * vec); \ + void hs_delete_vec_##name(vector * vec){ delete vec; } \ + \ + extern "C" vector > * hs_new_vec_vec_##name(type x[], int y, int z[]); \ + vector > * 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 > * vec); \ + void hs_delete_vec_vec_##name(vector > * vec){ delete vec; } \ + \ + extern "C" void hs_vec_copy_##name(vector * vec, type outputs[]); \ + void hs_vec_copy_##name(vector * vec, type outputs[]){hs_vec_copy_T(vec, outputs);} \ + extern "C" int hs_vec_size_##name(vector * vec); \ + int hs_vec_size_##name(vector * vec){ return vec->size(); } \ + \ + extern "C" int hs_vec_vec_size_##name(vector > * vec); \ + int hs_vec_vec_size_##name(vector > * vec){ return vec->size(); } \ + extern "C" void hs_vec_vec_sizes_##name(vector > * vec, int sizes[]); \ + void hs_vec_vec_sizes_##name(vector > * vec, int sizes[]){ \ + hs_vec_vec_sizes_T(vec, sizes); \ + } \ + extern "C" void hs_vec_vec_copy_##name(vector > * vec, type* outputs[]); \ + void hs_vec_vec_copy_##name(vector > * 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) diff --git a/cbits/marshal.hpp b/cbits/marshal.hpp new file mode 100644 --- /dev/null +++ b/cbits/marshal.hpp @@ -0,0 +1,106 @@ +#ifndef __MARSHAL_THEM_BINDINGS_H__ +#define __MARSHAL_THEM_BINDINGS_H__ + +#include +#include + + +template +class Marshaling { + public: + static T1 marshal(T2 x) { + return x; + } +}; + +template +class Marshaling< T, T* > { + public: + static T marshal(T* x){ + return *x; + } +}; + +template +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::marshal(inputs[k]) ); + } + return vec; + } +}; +// pointer to ref +template +class Marshaling< std::vector< T1 >,std::vector< T2* > *> { + public: + static std::vector< T1 > marshal(const std::vector< T2* > * inputs){ + return Marshaling< std::vector, std::vector& >::marshal(*inputs); + } +}; + + +template +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::marshal(inputs[k]) ); + } + return vec; + } +}; +// pointer to ref +template +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, const std::vector & >::marshal(*inputs); + } +}; + + +template +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, std::vector< T2*> &>::marshal(inputs[k]) ); + } + return vec; + } +}; +// pointer to ref +template +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 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, const std::vector< T2* > &>::marshal(inputs[k]) ); + } + return vec; + } +}; +// pointer to ref +template +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__